{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "71e6d8fe-84c4-47d7-8fd7-f6a66fed72e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports \n",
    "import os\n",
    "import json\n",
    "import operator\n",
    "import pandas as pd\n",
    "from io import StringIO\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# settings\n",
    "BotHash = \"BEEB1E1549DDD01226DC2FC912ABAE49\"\n",
    "BotName = \"PokerShark2\"\n",
    "SB = 10\n",
    "\n",
    "# players\n",
    "Players = ['PokerShark1']\n",
    "\n",
    "# helper functions\n",
    "def prettyPrint(*arguments):\n",
    "    out = ''\n",
    "    for arg in arguments:\n",
    "        space = (30-len(arg)) * \" \"\n",
    "        out += arg + space\n",
    "    print(out)\n",
    "\n",
    "# gets an array of paths to player games\n",
    "def getGamesPath(playerName):\n",
    "    return [os.path.join(playerName,f) for f in os.listdir(playerName) if not f.startswith('.')]\n",
    "\n",
    "# Load game as json object.\n",
    "def loadGame(path):\n",
    "    with open(path) as f:\n",
    "        g = json.load(f)\n",
    "        # Throw if game not logged by the current version of the bot\n",
    "        if g[\"BotHash\"] != BotHash:\n",
    "            #raise Exception(\"BotHash does not match: \" + g[\"BotHash\"])\n",
    "            pass\n",
    "        return g\n",
    "\n",
    "# game statistics\n",
    "def getGamesCount(playerName):\n",
    "    # returns number of games played against the given player.\n",
    "    return len(getGamesPath(playerName))\n",
    "\n",
    "def getGameResultForPlayer(game, playerName):\n",
    "    # returns game result for given player.\n",
    "    results = game[\"Results\"]\n",
    "    maxStack = 0\n",
    "    hasMax = []\n",
    "    # find max stack\n",
    "    for result in results:\n",
    "        if maxStack < result[\"Stack\"]:\n",
    "            maxStack = result[\"Stack\"]\n",
    "            hasMax= [result[\"Player\"][\"Name\"]]\n",
    "        elif maxStack == result[\"Stack\"]:\n",
    "            hasMax.append(result[\"Player\"][\"Name\"])\n",
    "    # find player result\n",
    "    if playerName in hasMax:\n",
    "        if len(hasMax) > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonGamesCount(playerName):\n",
    "    # returns number of games won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'W':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewGamesCount(playerName):\n",
    "    # return number of games drew against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'D':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getLostGamesCount(playerName):\n",
    "    # return number of games lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'L':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getEndStack(playerName):\n",
    "    # return sum of the stack after the games.\n",
    "    s = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for result in game[\"Results\"]:\n",
    "            if result[\"Player\"][\"Name\"] == BotName:\n",
    "                s += result[\"Stack\"]\n",
    "    return s\n",
    "            \n",
    "# round statistics\n",
    "def getRoundsCount(playerName):\n",
    "    # returns number of rounds played against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        count += len(game[\"Rounds\"])\n",
    "    return count\n",
    "\n",
    "def GetRoundResultForPlayer(r, playerName):\n",
    "    results = r[\"Winner\"]\n",
    "    winners = len(results)\n",
    "    won = False\n",
    "    for result in results:\n",
    "        if playerName == result[\"Name\"]:\n",
    "            won = True\n",
    "            break\n",
    "    if won:\n",
    "        if winners > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonRoundsCount(playerName):\n",
    "    # returns number of rounds won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'W':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewRoundsCount(playerName):\n",
    "    # return number of games rounds against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'D':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getLostRoundsCount(playerName):\n",
    "    # return number of rounds lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'L':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def endedBeforeShowdown(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\":\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def botFolded(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\" and action[\"PlayerName\"] == BotName:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def getPaid(r,playerName):\n",
    "    # returns amount paid by player\n",
    "    amount = 0\n",
    "    # blinds\n",
    "    sbp = r['SmallBlindPosition']\n",
    "    for p in range(len(r['Players'])):\n",
    "        if r['Players'][p]['Name'] == playerName:\n",
    "            if p == sbp:\n",
    "                amount += SB\n",
    "            else:\n",
    "                amount += SB + SB\n",
    "    # calls and raises\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] != \"Fold\" and action[\"PlayerName\"] == playerName:\n",
    "            amount += action[\"Amount\"]\n",
    "    return amount\n",
    "\n",
    "# winning statistics\n",
    "def getNonShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if endedBeforeShowdown(r):\n",
    "                if botFolded(r):\n",
    "                    line -= getPaid(r,BotName)\n",
    "                else:\n",
    "                    line += getPaid(r,playerName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if not endedBeforeShowdown(r):\n",
    "                # if bot won\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                    line += getPaid(r,playerName)\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                    line -= getPaid(r,BotName)\n",
    "                \n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getStackLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                line += getPaid(r,playerName)\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                line -= getPaid(r,BotName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def plotWinnings(playerName):\n",
    "    # NonShowdownWinningsLine\n",
    "    x,y = getNonShowdownWinningsLine(playerName)\n",
    "    fig, ax = plt.subplots()\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Non-showdown winnings', c='r')\n",
    "    # ShowdownWinningsLine\n",
    "    x,y = getShowdownWinningsLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Showdown winnings', c='b')\n",
    "    # Stack\n",
    "    x,y = getStackLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Winnings', c='g')\n",
    "    # show plot\n",
    "    y_max = np.abs(ax.get_ylim()).max()\n",
    "    ax.set_ylim(ymin=-y_max, ymax=y_max)\n",
    "    ax.set_xlim(left=0)\n",
    "    plt.legend()\n",
    "    plt.grid(linestyle = '--', linewidth = 0.5)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# Print Results\n",
    "def PrintResult():\n",
    "    for player in Players:\n",
    "        prettyPrint(\"Results against:\", player)\n",
    "        # game statistics\n",
    "        n = getGamesCount(player)\n",
    "        w = getWonGamesCount(player)\n",
    "        d = getDrewGamesCount(player)\n",
    "        l = getLostGamesCount(player)\n",
    "        prettyPrint(\"number of games:\",str(n))\n",
    "        prettyPrint(\"number of games won:\", str(w) , \"{:.1f}\".format(w*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games drew:\", str(d), \"{:.1f}\".format(d*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games lost:\", str(l), \"{:.1f}\".format(l*100/n) + \"%\")\n",
    "        # round statistics\n",
    "        rn = getRoundsCount(player)\n",
    "        rw = getWonRoundsCount(player)\n",
    "        rd = getDrewRoundsCount(player)\n",
    "        rl = getLostRoundsCount(player)\n",
    "        prettyPrint(\"number of rounds:\",str(rn))\n",
    "        prettyPrint(\"number of rounds won:\", str(rw) , \"{:.1f}\".format(rw*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds drew:\", str(rd), \"{:.1f}\".format(rd*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds lost:\", str(rl), \"{:.1f}\".format(rl*100/rn) + \"%\")\n",
    "        # winnings\n",
    "        prettyPrint(\"starting stack:\", str(1000 * n))\n",
    "        prettyPrint(\"end stack:\", str(getEndStack(player)))\n",
    "        prettyPrint(\"win/loss:\", str(getEndStack(player) - (1000 * n)  ))\n",
    "        prettyPrint(\"WPH:\", str((getEndStack(player) - (1000 * n)) / (rn*10)))\n",
    "        plotWinnings(player)\n",
    "        # end\n",
    "        print('-------------------------------------------------------------')\n",
    "        \n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f45a61bb-8373-4bd1-8fd6-b85a124517bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dynamic player:\n",
      "Results against:              PokerShark2                   \n",
      "number of games:              100                           \n",
      "number of games won:          49                            49.0%                         \n",
      "number of games drew:         3                             3.0%                          \n",
      "number of games lost:         48                            48.0%                         \n",
      "number of rounds:             10000                         \n",
      "number of rounds won:         5008                          50.1%                         \n",
      "number of rounds drew:        2                             0.0%                          \n",
      "number of rounds lost:        4990                          49.9%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    101050.0                      \n",
      "win/loss:                     1050.0                        \n",
      "WPH:                          0.0105                        \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "risk-averse player:\n",
      "Results against:              PokerShark1                   \n",
      "number of games:              100                           \n",
      "number of games won:          48                            48.0%                         \n",
      "number of games drew:         3                             3.0%                          \n",
      "number of games lost:         49                            49.0%                         \n",
      "number of rounds:             10000                         \n",
      "number of rounds won:         4990                          49.9%                         \n",
      "number of rounds drew:        2                             0.0%                          \n",
      "number of rounds lost:        5008                          50.1%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    98950.0                       \n",
      "win/loss:                     -1050.0                       \n",
      "WPH:                          -0.0105                       \n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAGdCAYAAAAWp6lMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAADIGklEQVR4nOydd3hURduH703vm0YSQgIECCQQIJSAoAgoTRTEXlEsiAoiL9hQP0FUsIBYULDjq9heFSwoggpIJ5RQQqiGEkJIIL2Xne+Pkz3Jkg5JZpPMfV177Z45c855zi+Ts8/OPPOMQQghUCgUCoVCoWjG2Mg2QKFQKBQKhaKhUQ6PQqFQKBSKZo9yeBQKhUKhUDR7lMOjUCgUCoWi2aMcHoVCoVAoFM0e5fAoFAqFQqFo9iiHR6FQKBQKRbNHOTwKhUKhUCiaPXayDbAWTCYTiYmJuLu7YzAYZJujUCgUCoWiFgghyMrKIjAwEBubqvtxlMNTSmJiIsHBwbLNUCgUCoVCcRGcOnWKoKCgKvcrh6cUd3d3QBPMw8NDsjUti6SkJAICAmSb0SJR2stB6S4Ppb0cGlL3zMxMgoOD9e/xqlAOTynmYSwPDw/l8DQyOTk5SnNJKO3loHSXh9JeDo2he03hKCpoWSGdkydPyjahxaK0l4PSXR5KezlYg+7K4VEoFAqFQtHsMQghhGwjrIHMzEyMRiMZGRmqu7ORyc/Px8nJSbYZLRKlvRyU7vJQ2suhIXWv7fe3iuFRSOfYsWN069ZNthktEqX9xSOEoLi4mJKSkjofe+TIEUJDQxvAKkVNKO3lcCm629raYmdnd8kpY5TDo5BOdna2bBNaLEr7i6OwsJAzZ86Qm5t7UceXlJQQHx9fz1YpaoPSXg6XqruLiwutW7fGwcHhos+hHB6FdFxcXGSb0GJR2tcdk8lEfHw8tra2BAYG4uDgUOdfnnl5eTg7OzeQhYrqUNrL4WJ1F0JQWFhISkoK8fHxhIaGVptcsDqUw6OQTlhYmGwTWixK+7pTWFiIyWQiODj4oh1GBweHi35oKy4Npb0cLkV3Z2dn7O3tOXHiBIWFhRcdC6T+6grp7Nq1S7YJLRal/cVzKV+aFzsUprh0lPZyuFTd68NJVQ6PQqFQKBSKZo9yeBTSqW7tE0XDorSXw6UEXjZXjh8/jsFgICYmpkGvU5P2s2fPJjIyskFtaEjWrVuHwWAgPT29Xs/bvn173nrrrYs+3hravHJ4FNKxs1OhZLJQ2svhUqfXXiwTJkzAYDDw6quvWpSvWLFCmk2NTXO/z4EDB3LmzBmMRmO9njc6OpqHHnrooo+3Bt2Vw6OQzvHjx2Wb0GJR2suhoKBA2rWdnJx47bXXSEtLk2aDTGRq3xg4ODgQEBBQ7w5Gq1atLmlWpzXorhwehUKhaEEMGzaMgIAA5s2bV229H374gW7duuHo6Ej79u1ZsGCBxf727dszd+5c7r//ftzd3Wnbti0ffvhhtedMS0vjrrvuolWrVjg7OxMaGspnn31mUefff/9l6NChuLi40LNnT7Zs2VJru9599126d++ub5t7rt577z29bNy4ccycOVPffvXVV/H398fd3Z0HHniA/Px8i+uZTCbmzJlDUFAQjo6OREZGsmrVKn3/TTfdxGOPPaZvT5s2DYPBQGxsLADFxcW4u7vzxx9/ADBkyBCmTp3KU089hbe3NwEBAcyePbtKzfbt24eNjQ3nzp3TNbSxseGWW27R68ybN48BAwYAFYe0li5diqenJ3/88Qfh4eG4ubkxatQozpw5ox8/YcIExo0bx/z582ndujU+Pj5MnjyZoqIivc6FQ1oGg4GPP/6YG264ARcXF0JDQ/n5558tbP/5558JDQ3F2dmZ0aNH8/nnn1vYduLECcaMGYOXlxeurq5069aN3377rUotLhmhEEIIkZGRIQCRkZEh25QWR05OjmwTWixK+7qTl5cnDhw4IPLy8i76HMXFxfVoUe259957xfXXXy9+/PFH4eTkJE6dOiWEEGL58uWi/NfBjh07hI2NjZgzZ444dOiQ+Oyzz4Szs7P47LPP9Drt2rUT3t7e4r333hNHjhwR8+bNEzY2NiIuLq7K60+ePFlERkaK6OhoER8fL9asWSN+/vlnIYQQ8fHxAhBhYWHi119/FYcOHRI333yzaNeunSgqKqqVXXv37hUGg0GkpKQIIYSYNm2a8PX1FbfccosQQoiioiLh5uYmfv/9dyGEEN9++61wcHAQH330kTh48KB47rnnhLu7u+jZs6du85tvvik8PDzE119/LQ4ePCieeuopYW9vLw4fPiyEEOKdd94RERERev3IyEjh6+sr3nvvPSGEEJs3bxZ2dnYiKytLCCHE4MGDhYeHh5g9e7Y4fPiw+Pzzz4XBYBCrV6+uVDOTySR8fX3F999/L4QQYsWKFcLX11f4+fnpdUaMGCGefvppIYQQa9euFYBIS0sTQgjx2WefCXt7ezFs2DARHR0tdu7cKcLDw8Wdd95p0S48PDzEww8/LOLi4sQvv/wiXFxcxIcffmjx9164cKG+DYigoCDx1VdfiSNHjoipU6cKNzc3cf78ef3vaW9vL5544glx8OBBsWzZMtGmTRsL26699loxfPhwsXfvXnHs2DHxyy+/iPXr11eqQ3X/d7X9/lYOTynK4ZFHdQ9IRcOitK87VT54c3KE2LmzVq+8TZtqXbfGVx2cVrPDI4QQl112mbj//vuFEBUdnjvvvFMMHz7c4tgnn3xSdO3aVd9u166duPvuu/Vtk8kk/Pz8xOLFi6u8/pgxY8R9991X6T6zw/Pxxx/rZbGxsQLQ22lNdl3oHERGRop58+bpzsGFzseAAQPEww8/bHG+/v37Wzg8gYGB4pVXXrGoExUVJR599FEhhKWTlZqaKuzt7cXLL7+sO1lz584V/fv3148dPHiwuOKKKyqcz+ywVMaNN94opkyZIoTQnLgZM2YIX19fERsbW8GJq8zhAcTRo0f187333nvC399f37733ntFu3btLBzxW265Rdx22236dmUOz/PPP69vZ2dnC4PBoNvx9NNPWziCubm54rnnnrOwrXv37mL27NlV3nd56sPhURGLCulkZGTINqHForSvRw4ehD59alW1XpdQ3LkTeveu82GvvfYaV111FTNmzKiwLy4ujuuvv96i7PLLL+ett96ipKQEW1tbAHr06KHvNxgMBAQEkJycDMA111zDhg0bAGjXrh2xsbE88sgj3HTTTezatYsRI0Ywbtw4Bg4caHGd8uds3bo1AMnJyYSFhdXKriuvvJJ169Zx9dVXExsby8MPP8z8+fOJi4tj3bp1REZG4ubmpt/nww8/bHG+AQMGsHbtWkBblDIxMZHLL7+8wjX37NkDQEREBD4+Pqxfvx57e3t69uzJ2LFjeeeddwBtiGnw4MFV3qP5Ps26VcaQIUP04cL169fz0ksvER8fz/r168nIyCAvL6+CjeVxcXGhY8eO1V6vW7du+t/VXGffvn1VnvPC+3B1dcXd3V0/76FDh4iKitL3l5SU0K9fP4vjp06dyiOPPMLq1asZNmwYN910UwVt6hPl8Ciko1YulofSvh4JC9Ocj1pQr8sbXGS27CuvvJKRI0fy7LPPMmHCBIt9QogKQa/aj3pL7O3tLbYNBgMmkwmAjz/+mLy8PIt611xzDSdOnGDlypX8+eefXH311UyePJn58+dXek6zDeZz1sYus3OwYcMGevbsiaenJ1deeSXr169n3bp1DBo0qHphKqGya5rLDAaD7mQ5ODgwZMgQIiIiKCkpYd++fWzevJlp06ZZHF+dbpUxZMgQHn/8cY4ePcr+/fsZNGgQx44dY/369aSnp9OnTx/c3d2rPL6y612oW11tqumYC/9WNjY2Fa754IMPMnLkSFauXMnq1auZN28eCxYssIiJqk+Uw6OQTkREhGwTWixK+3rExaXWPS1OQoAVTNN99dVXiYyMpHPnzhblXbt2ZePGjRZlmzdvpnPnzha9ANXRpk2bSstbtWrFhAkTmDBhAoMGDeLJJ5+0cHiqozZ2mZ2D77//niFDhgAwePBg/vzzTzZv3szUqVP1Y8PDw9m6dSv33HOPXrZ161b9s4eHB4GBgWzcuJErr7zS4prleyvMTpaDgwNz5szBYDAwaNAg5s+fX2PvS20w9yK9/PLL9OzZEw8PDwYPHsy8efNIS0ur0INkDYSFhVkEIDs7O7Njx44K9YKDg3n44Yd5+OGHmTlzJh999FGDOTxqlpZCOpX9EygaB6W9HHJycmSbAED37t256667ePfddy3KZ8yYwV9//cVLL73E4cOH+fzzz1m0aBFPPPHEJV3vhRde4KeffuLo0aPExsby66+/Eh4eXuvja2OX2TlYtmyZ7vAMGTKEFStWkJeXR69evfS6jz/+OJ9++imffvophw8fZtasWfrsKjNPPvkkr732Gt9++y2HDh3imWeeISYmhscff1yvM2TIEGJjY9m3b5/egzRkyBCWLVtG79698fDwuBi5dMy9SF9++aV+Tz169KCwsJC//vpLL7MmJk2axMGDB3n66ac5fPgwX3zxBUuXLgXKesymTZvGH3/8QXx8PLt27eLvv/+uU3uoK8rhUSgUihbMSy+9VGGooXfv3nz33Xd88803RERE8MILLzBnzpwKQ191xcHBgZkzZ9KjRw+uvPJKbG1t+eabb2p9fG3sMhgMeo+H2fno0aMHRqORXr16WTgft912Gy+88AJPP/00ffr04cSJEzzyyCMW15w6dSozZsxgxowZdO/enVWrVunTrc1ERETg6+ur976A1qtUUlJSb70vQ4cOpaSkRHduzL1IAFdccUW9XKM+CQkJ4fvvv+fHH3+kR48efPzxxzz33HMAODo6Alpcz+TJkwkPD2fUqFF06dKF999/v8FsMojKBmZbIJmZmRiNRjIyMi7ZG1fUjZMnT9K2bVvZZrRIlPZ1Jz8/n/j4eEJCQi46BqqgoEB/6CsaF6W9HAoKCpg/fz5Llizh1KlTdT6+uv+72n5/qxgehXQuJXun4tJQ2suhPlZ+VlwcSvvG4/333ycqKkqfxfbGG28wZcoUafYoh0chnWPHjuHr6yvbjBaJ0l4OBQUFFWa4KBoHpX3jceTIEV5++WVSU1MJCgpixowZFlmuGxvl8CgUCoVCoah3Fi5cyMKFCwHIzs7W8x/JQvXtKaTTrVs32Sa0WJT2cqi3HDyKOqO0l4M16K4cHoV0EhMTZZvQYlHay6H8ooyKxkVpLwdr0F05PArppKWlyTahxaK0l0NxcbFsE1osSns5WIPuyuFRSEcFEMpDaS+HC5cqUDQeSns5WIPuyuFRSKf3RSx8qKgflPZycHV1lW1Ci0VpLwdr0F05PArpbNu2TbYJLRalvRyys7Nlm9BiUdrLwRp0Vw6PQqFQKHQMBgMrVqyQasPSpUvx9PSUasOlcPz4cQwGAzExMfV63iFDhlRYeV1Re5TDo5COv7+/bBNaLEp7OciKnUpOTmbSpEm0bdsWR0dHAgICGDlyJFu2bJFijwwaQ/vg4GDOnDlDREREvZ73xx9/5KWXXqrXczYW1hAvqBIPKqSj1i6Th9JeDra2tlKue9NNN1FUVMTnn39Ohw4dOHv2LH/99RepqalS7JFBY2hva2tLQEBAvZ/X29u73s/ZWMhq8+VRPTwK6Rw5ckS2CS0Wpb0c8vPzG/2a6enpbNy4kddee42hQ4fSrl07+vXrx8yZM7n22mst6p47d44bbrgBFxcXQkND+fnnny32r1+/nn79+uHo6Ejr1q155pln9GnHv/zyC56enphMJgBiYmIwGAw8+eST+vGTJk3ijjvu0LeXLl1K27ZtcXFx4YYbbuD8+fMV7F+8eDEdO3bEwcGBLl268MUXX+j7ZsyYwZgxY/Ttt956C4PBwMqVK/WyLl268MEHH5Cfn8+ECRMYN24c8+fPp3Xr1vj4+DB58uQqc8VkZGRga2vLzp07ARBC4O3tTVRUlF7n66+/pnXr1kDFIa1169ZhMBj466+/6Nu3Ly4uLgwcOJBDhw7px8+ePZvIyEi++OIL2rdvj9Fo5PbbbycrK0uvc+GQVvv27Zk7dy73338/7u7utG3blg8//NDC9s2bNxMZGYmTkxN9+/ZlxYoVFralpaVx11130apVK5ydnQkNDeWzzz6rVIdLQUabv5AGdXgWL15Mjx498PDwwMPDgwEDBvD777/r+4UQzJ49m8DAQJydnRkyZAixsbEW5ygoKOCxxx7D19cXV1dXxo4dS0JCgkWdtLQ0xo8fj9FoxGg0Mn78eNLT0xvy1hQKhaJJ4ebmhpubGytWrKCgoKDaui+++CK33nore/fuZfTo0dx11116L9Dp06cZPXo0UVFR7Nmzh8WLF/PJJ5/w8ssvA3DllVeSlZXF7t27Ac058vX1Zf369fr5161bx+DBgwEtcP7+++/n0UcfJSYmhqFDh+rnMrN8+XIef/xxZsyYwf79+5k0aRL33Xcfa9euBTRHYMOGDbqTdeE1k5KSOHz4sH5NgLVr13Ls2DHWrl3L559/ztKlS1m6dGmlehiNRiIjI1m3bh0Ae/fu1d8zMzMr3FNVPPfccyxYsIAdO3ZgZ2fH/fffb7H/2LFjrFixgl9//ZVff/2V9evX8+qrr1Z7zgULFtC3b192797No48+yiOPPMLBgwcByMrKYsyYMXTv3p1du3bx0ksv8fTTT1sc/3//938cOHCA33//nbi4OBYvXtx819cTDcjPP/8sVq5cKQ4dOiQOHToknn32WWFvby/2798vhBDi1VdfFe7u7uKHH34Q+/btE7fddpto3bq1yMzM1M/x8MMPizZt2og1a9aIXbt2iaFDh4qePXuK4uJivc6oUaNERESE2Lx5s9i8ebOIiIgQ1113XZ1szcjIEIDIyMion5tX1BqluTyU9nUnLy9PHDhwQOTl5VmU5+QIsXNn7V7btxfXum5Nr5yc2tv+/fffCy8vL+Hk5CQGDhwoZs6cKfbs2WNRBxDPP/+8vp2dnS0MBoP4/fffhRBCPPvss6JLly7CZDLpdd577z3h5uYmSkpKhBBC9O7dW8yfP18IIcS4cePEK6+8IhwcHERmZqY4c+aMAERcXJwQQog77rhDjBo1ysKG2267TRiNRn174MCBYuLEiRZ1brnlFjF69GghhBDp6enCxsZG7NixQ5hMJuHj4yPmzZsnoqKihBBCfPXVV8Lf318IIURxcbG49957Rbt27Sy+R2655RZx2223Vand9OnT9e+Vt956S9x8882id+/eYuXKlUIIITp37iwWL14shBAiPj5eAGL37t1CCCHWrl0rAPHnn3/q51u5cqUA9HY0a9Ys4eLiYvH99+STT4r+/fvr24MHDxaPP/64vt2uXTtx991369smk0n4+fnpdixevFj4+PhYtNWPPvrIwrYxY8aI++67r8r7ri/Ka30xVPV/J0Ttv78bNIanfBcjwCuvvMLixYvZunUrXbt25a233uK5557jxhtvBODzzz/H39+fr776ikmTJpGRkcEnn3zCF198wbBhwwD48ssvCQ4O5s8//2TkyJHExcWxatUqtm7dSv/+/QH46KOPGDBgAIcOHaJLly4NeYuKeiA5OVnFkkhCaV9/HDwIffrUtnb9xTPs3Am1Tad00003ce2117Jhwwa2bNnCqlWreP311/n444+ZMGGCXq9Hjx76Z1dXV9zd3UlOTgYgLi6OAQMGWCSSu/zyy8nOziYhIYG2bdsyZMgQ1q1bx/Tp09mwYQMvv/wyP/zwAxs3biQ9PR1/f3/CwsL0891www0Wdg4YMIBVq1bp23FxcTz00EMWdS6//HLefvttwLIHxt7eHhsbGyZNmsSsWbPIysqy6H0xD1t169bNIq6kdevW7Nu3r0rthgwZwieffILJZGL9+vVcffXVtG3blvXr19O7d+8KPUiVUV5X8/BXcnIybdu2BbQhKnd3d4s6Zt1rc06DwUBAQIB+zKFDh+jRowdOTk56nX79+lkc/8gjj3DTTTexa9cuRowYwbhx4xg4cGC117wYioqKpMfxNFrQcklJCf/73//IyclhwIABxMfHk5SUxIgRI/Q6jo6ODB48mM2bNzNp0iR27txJUVGRRZ3AwEAiIiLYvHmzPrvAaDTqzg7AZZddhtFoZPPmzVU6PAUFBRbduuZuSUXjc/78eTp16iTbjBaJ0r7+CAvTnI/akJubi4uLS71dty44OTkxfPhwhg8fzgsvvMCDDz7IrFmzLByeC2fUGAwGfbhICFEha64QQq8HZc7Bnj17sLGxoWvXrgwePJj169eTlpZm4RiYj62Jyq5ZvszsZDk4ODB48GC8vLzo1q0bmzZtYt26dXrsiznWqLp7rAzzUN2uXbvYsGEDL730EsHBwcydO5fIyEj8/PwIDw+v9h7KX9Nse/lr1tWmmo6p7m9l5pprruHEiROsXLmSP//8k6uvvprJkyczf/78aq9bV6xhaYkGd3j27dvHgAEDyM/Px83NjeXLl9O1a1c2b94MVJwW6+/vz4kTJwBt3NXBwQEvL68KdZKSkvQ6fn5+Fa7r5+en16mMefPm8eKLL1Yo37FjB66urvTu3Zu4uDjy8vJwd3cnJCREH7dt164dJpOJU6dOARAZGcnRo0fJzs7G1dWVzp076+PXQUFB2Nra6vfUo0cPjh8/TmZmJk5OTnTr1k0PhAsMDMTJyYl///0XgIiICBISEkhPT8fBwYHIyEi2b98OQEBAAG5ubhw9ehSA8PBwzp49S2pqKnZ2dvTp04ft27cjhKBVq1Z4eXlx+PBhQAveS01NJSUlBRsbG6KiotixYwclJSX4+Pjg5+dHXFwcAKGhoWRmZnL27FkA+vfvz65duygqKsLLy4vAwEA97qpjx47k5uZy5swZAPr27cv+/fvJz8/HaDTStm1b/RdU+/btKS4u1u+vqKiIgwcPkpubi5ubGx07dmTPnj0A+q+fkydPAtCzZ0+OHTtGdnY2Li4uhIWFsWvXLl1vOzs7jh8/DkD37t05efIkGRkZODk5ERERwY4dOwDt15OLiwvHjh0DtF98iYmJpKWlYW9vT+/evfXEfP7+/nh4eOhBvuHh4SQnJ3P+/HlsbW3p27cv0dHRmEwmWrVqhbe3tx6Q2LlzZ9LS0khJScFgMNCvXz927txJcXEx3t7e+Pv763p36tSJ7Oxsve3269ePmJgYCgsL8fT0JCgoiP379wPQoUMH8vPz9QVA+/TpQ2xsLPn5+Xh4eNC+fXuLNltSUqLHv/Xq1YvDhw+Tnp5ObGwsnTp10oMYg4ODsbGxsWiz8fHxZGVl4ezsTHh4uK53mzZtcHBwID4+Xtf71KlTpKen4+joSI8ePYiOjtbbrKurq653165dSUpKIjU1tYLefn5+GI1GXe+wsDDOnTvHuXPn9DZr1tvX1xdfX189biE0NJSMjAz9V275Nuvt7U1AQAAHDhzQ22xOTo6ud1RUFHv37qWgoABPT0+Cg4P1NhsSEkJhYSGnT5/G0dERk8lEbm4uJpMJW1tbnJwc6dw5F9B+vAkhKCwsBMDFxYWCggJKSkqwtbXFZBIIoSVic3BwwGAw6D/Ayte1sbHB2dmZnJycSus6OztTVFREdnZxhbr29vbY2trqwaLmusXFxRgMBlxdXcnJyaFjx46sWLGC4uJivW5JSQkFBQUUFRXpX5gFBQVkZ2fTuXNnfvrpJ7KysjAYDDg5OfHPP//g7u6O0WjU22JWVhYLFizgyiuvJCcnh379+rFw4ULS0tJ45JFHLJ6XmzZtIi8vDwcHB/Ly8ti4cSMAhYWFFBYW0rlzZzZs2MDNN9+s671p0yZCQ0PJzs7GwcGByy+/nE8++QSAkSNHkpeXx8CBA/nyyy85fPgwUVFRZGdnI4TAZDJRXFxMdnY2zs7OFBYWUlRUhMlkQghhoaGNjQ0FBQXY2toSGRmp9yq1a9eOwMBAdu/ezYoVKxg0aJCuofl4s2Z5eXkA5OTkYGdnh729ve4A5OTkUFxcTHFxMSaTiZycHP1vU1BQgBCCkpIS8vLyKCkpwWQy6X8bIQRCCL0d2tnZ6bplZ2cTGhrKsmXLOH/+PI6Ojri6uurfvfn5+XobdnZ25q677uLOO++kX79+PP/887z++usWbdbR0ZHc3NxatVknJ6cKdUtKSnS9ze2wsjZr1vvCNmv+XzJ/L5R/RpiPr5FLGlSrBQUFBeLIkSMiOjpaPPPMM8LX11fExsaKTZs2CUAkJiZa1H/wwQfFyJEjhRBCLFu2TDg4OFQ457Bhw8SkSZOEEEK88soronPnzhXqdOrUScybN69Ku/Lz80VGRob+OnXqlIrhUSgUNVJdLIE1c+7cOTF06FDxxRdfiD179oh///1XfPfdd8Lf31/cf//9ej1ALF++3OJYo9EoPvvsMyGEEAkJCcLFxUVMnjxZxMXFiRUrVghfX18xa9Ysi2N69+4tbG1txaJFi4QQQqSmpgp7e3sBiNjYWL3eli1bhMFgEK+99po4dOiQePfdd4Wnp6dFDM/y5cuFvb29WLx4sTh8+LBYsGCBsLW1FWvXrtXrmON4bG1t9TjRFStWCFtbW9GqVSsL2+69915x/fXXW5Q9/vjjYvDgwdVqOH36dGFraytuvvlmvSwyMlLY2tqK9957Ty+rKoYnLS1Nr7N7924BiPj4eCGEFsPTs2dPi+stXLhQtGvXTt+uLIZn4cKFFsf07NlT/1tkZGQIb29vcc8994gDBw6IVatWibCwMAGImJgYIYQQ//d//ydWrFghjhw5Ivbv3y+uu+460a9fv2p1kEF9xPA0+LR0BwcHOnXqRN++fZk3bx49e/bk7bff1nMUXNgLk5ycrPf6BAQEUFhYWGFF5wvrmHsfypOSklJtUjVHR0d99pj5pZCDuQdA0fgo7eVQ61+k9Yibmxv9+/dn4cKFXHnllURERPB///d/TJw4kUWLFtX6PG3atOG3335j+/bt9OzZk4cffpgHHniA559/3qLe0KFDKSkpYciQIQB4eXnRtWtXWrVqZTH0c9lll/Hxxx/z7rvvEhkZyerVqyuca9y4cbz99tu88cYbdOvWjQ8++IDPPvtMPzdocTy9evXC29ubrl27AjBo0CBMJpPFENqlaH/hPQEMHjyYkpKSGuN3ZODh4cEvv/xCTEwMkZGRPPfcc7zwwgsAelyPg4MDM2fOpEePHlx55ZXY2tryzTff1LstMtp8BRrKG6uKq666Stx7773CZDKJgIAA8dprr+n7CgoKhNFoFEuWLBFCaB67vb29+Pbbb/U6iYmJwsbGRqxatUoIIcSBAwcEILZt26bX2bp1qwDEwYMHa22XmqUlj61bt8o2ocWitK879dHDk5WVVY8WKepCS9f+yy+/FPb29iI3N7dRr3upulv9LK1nn32Wa665huDgYLKysvjmm29Yt24dq1atwmAwMG3aNObOnUtoaCihoaHMnTsXFxcX7rzzTkDz2B944AFmzJiBj48P3t7ePPHEE3Tv3l2ftRUeHs6oUaOYOHEiH3zwAQAPPfQQ1113nZqh1URo1aqVbBNaLEp7OVhDmv2WSkvT/r///S8dOnSgTZs27Nmzh6effppbb70VZ2fnRrXDGnRvUIfn7NmzjB8/njNnzmA0GunRowerVq1i+PDhADz11FPk5eXx6KOPkpaWRv/+/Vm9erXFtLyFCxdiZ2fHrbfeSl5eHldffTVLly61mN62bNkypk6dqs/mGjt2bJ26aBVyacrp0ps6Sns5yJ6e25JpadonJSXxwgsvkJSUROvWrbnlllt45ZVXGt0Oa9DdIEQt5wQ2czIzMzEajWRkZKh4nkZm27ZtFmkFFI2H0r7u5OfnEx8fT0hIiEV+k7qQnZ2Nm5tbPVumqA1Kezlcqu7V/d/V9vtbraWlUCgUCoWi2aMcHoV0OnfuLNuEFovSXg4X2zOkuHSU9nKwBt2Vw6OQzoVpBxSNh9JeDiUlJbJNaLEo7eVgDborh0chnZSUFNkmtFiU9nIwr+ekaHyU9nKwBt2Vw6OQzoVrvSgaD6W9HJTu8lDay8EadFcOj0I6F67eq2g8lPZycHV1lW1Ci0VpLwdr0F05PArp7KztEtOKekdpLwerSLNfC9atW4fBYCA9Pb1ez9u+fXveeuutej1nbWkq2jc3rEF35fAopGNeNVjR+Cjt5SAj/dmSJUtwd3e3+JtnZ2djb2/PoEGDLOpu2LABg8FAYGCgnji2PomOjuahhx6q13PWFpV6Tg7WoLtyeBTSUdl+5aG0l4OdXYMmua+UoUOHkp2dzY4dO/SyDRs2EBAQQHR0NLm5uXr5unXrCAwMpHPnzgQEBNR7/EWrVq1wcXGp13PWFhnaK6xDd+XwKKRT3ar2ioZFaS8HGesKdenShcDAQNatW6eXrVu3juuvv56OHTuyefNmi/KhQ4dWGNJaunQpnp6e/PHHH4SHh+Pm5saoUaM4c+aMfuyECRMYN24c8+fPp3Xr1vj4+DB58mSLWToXDmkZDAY+/vhjbrjhBlxcXAgNDeXnn3+2sP/nn38mNDQUZ2dnhg4dyueff25h24kTJxgzZgxeXl64urrSrVs3fvvttwo6WMOaTi0Ra9BdOTwK6cTFxck2ocWitJdDXl6elOsOGTKEtWvX6ttr165lyJAhDB48WC8vLCxky5YtDB06tNJz5ObmMn/+fL744gv++ecfTp48yRNPPGFRZ+3atRw7doy1a9fy+eefs3TpUpYuXVqtbS+++CK33nore/fuZfTo0dx1112kpqYCcPz4cW6++WbGjRtHTEwMkyZN4rnnnrM4fvLkyRQUFPDPP/+wb98+XnvttUqXMpClfUvHGnSX38ekUCgUzYDcolwOnjtYu7q5ubhk1c+QTphvGC72tTvXkCFD+M9//kNxcTF5eXns3r2bK6+8kpKSEt555x0Atm7dSl5eHkOHDuXkyZMVzlFUVMSSJUvo2LEjAFOmTGHOnDkWdby8vFi0aBG2traEhYVx7bXX8tdffzFx4sQqbZswYQJ33HEHAHPnzuXdd99l+/btjBo1iiVLltClSxfeeOMNQOut2r9/v8UimCdPnuSmm26ie/fuAHTo0KFWmihaDsrhUUinU6dOsk1osSjt64+D5w7S58M+jX7dnQ/tpHfr3rWqO3ToUHJycoiOjiYtLY3OnTvj5+fH4MGDGT9+PDk5Oaxbt462bdvSoUOHSh0eFxcX3dkBaN26NcnJyRZ1unXrZrE6duvWrdm3b1+1tvXo0UP/7Orqiru7u37eQ4cOERUVZVH/wpQKU6dO5ZFHHmH16tUMGzaMm266yeKcZqxhiYOWiDXorhwehXSys7Px8fGRbUaLRGlff4T5hrHzodpN8y8sLMTBwaHerltbOnXqRFBQEGvXriUtLY3BgwcDEBAQQEhICJs2bWLt2rVcddVVVZ7jwlgMg8FQYQZOZXVMJlO1tlV3jBCiQuD0hdd88MEHGTlyJCtXrmT16tXMmzePBQsW8Nhjj1nUKykpsYoA2paGNeiu/uoK6SQlJdGuXTvZZrRIlPb1h4u9S617WrKzsyuNL2kMzMHIaWlpPPnkk3r54MGD+eOPP9i6dSv33XefFNuqIiwsrEIAcvnZZmaCg4N5+OGHefjhh5k5cyYfffRRBYenqKgIR0fHBrVXURFr0F0FLSsUCkULYujQoWzcuJGYmBi9hwc0h+ejjz4iPz+/yoBlWUyaNImDBw/y9NNPc/jwYb777js9CNrc8zNt2jT++OMP4uPj2bVrF3///Tfh4eESrVZYG8rhUUhHLW8gD6W9HGSm2R86dCh5eXl06tTJIi3B4MGDycrKomPHjgQHB0uzrzJCQkL4/vvv+fHHH+nRoweLFy/WZ2mZew1KSkqYPHky4eHhjBo1ii5duvD+++9XOJc1LHHQErEG3Q3CGtIfWgGZmZkYjUYyMjLw8PCQbU6LYvfu3fTq1Uu2GS0SpX3dyc/PJz4+npCQkIsOxMzNzZWWeK+58Morr7BkyRJOnTpVp+OU9nK4VN2r+7+r7fe3iuFRSKewsFC2CS0Wpb0cagrgVVTk/fffJyoqCh8fHzZt2sQbb7zBlClT6nwepb0crEF35fAopOPp6SnbhBaL0l4OsmerNEWOHDnCyy+/TGpqKm3btmXGjBnMnDmzzudR2svBGnSXb4GixRMUFCTbhBaL0l4O1pBmv6mxcOFCFi5ceMnnUdrLwRp0V0HLCuns379ftgktFqW9HKwhzX5LRWkvB2vQXTk8CoVCoVAomj3K4VFIR615Iw+l/cVzKRNcZSdga8ko7eVwqbrXx4Ry5fAopJOfny/bhBaL0r7umGMRcnNzL/ocKhuIPJT2crhU3c3/b5cSC6SClhXSSUxMtLpEZy0FpX3dsbW1xdPTU1/Y0sXFpcI6TzWRk5NjFYnYWiJKezlcrO5CCHJzc0lOTsbT09NiUdq6ohwehUKhqCMBAQEAFVYJry0FBQVqaEUSSns5XKrunp6e+v/dxaIyLZeiMi3Lo7i42CpyNLRElPaXRklJCUVFRXU+TukuD6W9HC5Fd3t7+2p7dlSmZUWTITY2lp49e8o2o0WitL80bG1tL6qLfc+ePUp3SSjt5WANuqugZYV0VOCsPJT2clC6y0NpLwdr0F05PArpqCFEeSjt5aB0l4fSXg7WoLtyeBTSad++vWwTWixKezko3eWhtJeDNeiuHB6FdPbu3SvbhBaL0l4OSnd5KO3lYA26K4dHoVAoFApFs0c5PArptGvXTrYJLRalvRyU7vJQ2svBGnRXDo9COiUlJbJNaLEo7eWgdJeH0l4O1qC7cngU0klISJBtQotFaS8Hpbs8lPZysAbdG9ThmTdvHlFRUbi7u+Pn58e4ceM4dOiQRR0hBLNnzyYwMBBnZ2eGDBlCbGysRZ2CggIee+wxfH19cXV1ZezYsRXES0tLY/z48RiNRoxGI+PHjyc9Pb0hb0+hUCgUCkUToUEdnvXr1zN58mS2bt3KmjVrKC4uZsSIEeTk5Oh1Xn/9dd58800WLVpEdHQ0AQEBDB8+nKysLL3OtGnTWL58Od988w0bN24kOzub6667zqKL7M477yQmJoZVq1axatUqYmJiGD9+fEPenqKe6NWrl2wTWixKezko3eWhtJeDVeguGpHk5GQBiPXr1wshhDCZTCIgIEC8+uqrep38/HxhNBrFkiVLhBBCpKenC3t7e/HNN9/odU6fPi1sbGzEqlWrhBBCHDhwQABi69atep0tW7YIQBw8eLBWtmVkZAhAZGRkXPJ9KurGvn37ZJvQYlHay0HpLg+lvRwaUvfafn83agxPRkYGAN7e3gDEx8eTlJTEiBEj9DqOjo4MHjyYzZs3A7Bz506Kioos6gQGBhIREaHX2bJlC0ajkf79++t1LrvsMoxGo17nQgoKCsjMzLR4KeRQvsdP0bgo7eWgdJeH0l4O1qB7oy0eKoRg+vTpXHHFFURERACQlJQEgL+/v0Vdf39/Tpw4oddxcHDAy8urQh3z8UlJSfj5+VW4pp+fn17nQubNm8eLL75YoXzHjh24urrSu3dv4uLiyMvLw93dnZCQED1xUrt27TCZTJw6dQqAyMhIjh49SnZ2Nq6urnTu3Jndu3cDEBQUhK2trX4/PXr04Pjx42RmZuLk5ES3bt3YuXMnoDlyTk5O/PvvvwBERESQkJBAeno6Dg4OREZGsn37dgACAgJwc3Pj6NGjAISHh3P27FlSU1Oxs7OjT58+bN++HSEErVq1wsvLi8OHDwPQpUsXUlNTSUlJwcbGhqioKHbs2EFJSQk+Pj74+fkRFxcHQGhoKJmZmZw9exaA/v37s2vXLoqKivDy8iIwMFCPuerYsSO5ubmcOXMGgL59+7J//37y8/MxGo20bduWffv2AVrWzeLiYhISEsjMzKSoqIiDBw+Sm5uLm5sbHTt2ZM+ePQC0bdsWgJMnTwLQs2dPjh07RnZ2Ni4uLoSFhbFr1y5dbzs7O44fPw5A9+7dOXnyJBkZGTg5OREREcGOHTsAaN26NS4uLhw7dgyAbt26kZiYSFpaGvb29vTu3Ztt27bp7c3Dw4MjR47oeicnJ3P+/HlsbW3p27cv0dHRmEwmWrVqhbe3tx6v1rlzZ9LS0khJScFgMNCvXz927txJcXEx3t7e+Pv763p36tSJ7Oxsvd3269ePmJgYCgsL8fT0JCgoiP379wPQoUMH8vPzSUxMBKBPnz7ExsaSn5+Ph4cH7du3t2izJSUleuxbr169OHz4MJmZmcTGxtKpUydiYmIACA4OxsbGxqLNxsfHk5WVhbOzM+Hh4brebdq0wcHBgfj4eF3vU6dOkZ6ejqOjIz169CA6Olpvs66urrreXbt2JSkpidTU1Ap6+/n5YTQadb3DwsI4d+4c586d09usWW9fX198fX05ePCg3mYzMjJITk6u0Ga9vb0JCAjgwIEDepvNycnR9Y6KimLv3r0UFBTg6elJcHCw3mZDQkIoLCzk9OnTAJf0jHB2dtbvVT0jan5GmPWuj2eEEIKzZ8+qZ0QtnxE5OTm4ubld8jMiMzOTbdu2NcgzorbOlEEIIWpV8xKZPHkyK1euZOPGjQQFBQGwefNmLr/8chITE2ndurVed+LEiZw6dYpVq1bx1Vdfcd9991FQUGBxvuHDh9OxY0eWLFnC3Llz+fzzzysERIeGhvLAAw/wzDPPVLCnoKDA4pyZmZkEBwfXuLy8ov4pKCjA0dFRthktEqW9HJTu8lDay6Ehdc/MzMRoNNb4/d0oQ1qPPfYYP//8M2vXrtWdHdC8OaBCL0xycrLe6xMQEEBhYSFpaWnV1jH/uihPSkpKhd4jM46Ojnh4eFi8FHIw/2pQND5Kezko3eWhtJeDNejeoA6PEIIpU6bw448/8vfffxMSEmKxPyQkhICAANasWaOXFRYWsn79egYOHAhoXXD29vYWdc6cOcP+/fv1OgMGDCAjI0PvygXYtm0bGRkZeh2FQqFQKBQtlwaN4Zk8eTJfffUVP/30E+7u7npPjtFoxNnZGYPBwLRp05g7dy6hoaGEhoYyd+5cXFxcuPPOO/W6DzzwADNmzMDHxwdvb2+eeOIJunfvzrBhwwBtrHTUqFFMnDiRDz74AICHHnqI6667ji5dujTkLSrqgeDgYNkmtFiU9nJQustDaS8Ha9C9QR2exYsXAzBkyBCL8s8++4wJEyYA8NRTT5GXl8ejjz5KWloa/fv3Z/Xq1bi7u+v1Fy5ciJ2dHbfeeit5eXlcffXVLF26FFtbW73OsmXLmDp1qj6ba+zYsSxatKghb09RT9jYqITfslDay0HpLg+lvRysQfdGC1q2dmob9KSof7Zt22aRUkDReCjt5aB0l4fSXg4NqbtVBS0rFAqFQqFQyET18JSienjkkZeXh7Ozs2wzWiRKezko3eWhtJdDQ+quengUTQZz0jpF46O0l4PSXR5KezlYg+7K4VFIp/xCsYrGRWkvB6W7PJT2crAG3ZXDo5CO6l6Wh9JeDkp3eSjt5WANuqsYnlJUDI88ioqKsLe3l21Gi0RpLweluzyU9nJoSN1VDI+iyWBeZE7R+Cjt5aB0l4fSXg7WoLtyeBQKhUKhUDR7lMOjkE6bNm1km9BiUdrLQekuD6W9HKxBd+XwKKTj4OAg24QWi9JeDkp3eSjt5WANuiuHRyEda8jP0FJR2stB6S4Ppb0crEF35fAoFAqFQqFo9qhp6aWoaenyyM3NxcXFRbYZLRKlvRyU7vJQ2suhIXVX09IVTYZTp07JNqHForSXg9JdHkp7OViD7srhUUgnPT1dtgktFqW9HJTu8lDay8EadFcOj0I6jo6Osk1osSjt5aB0l4fSXg7WoLuK4SlFxfDIw2QyYWOjfG8ZKO3loHSXh9JeDg2pu4rhUTQZoqOjZZvQYlHay0HpLg+lvRysQXfl8CgUCoVCoWj2KIdHIZ2AgADZJrRYlPZyULrLQ2kvB2vQXTk8Cum4urrKNqHForSXg9JdHkp7OViD7srhUUjn2LFjsk1osSjt5aB0l4fSXg7WoLtyeBQKhUKhUDR7lMOjkE7Xrl1lm9BiUdrLQekuD6W9HKxBd+XwKKSTlJQk24QWi9JeDkp3eSjt5WANuiuHRyGd1NRU2Sa0WJT2clC6y0NpLwdr0F05PArp2NvbyzahxaK0l4PSXR5KezlYg+5qaYlS1NISCoVCoVA0PdTSEoomw7Zt22Sb0GJR2stB6S4Ppb0crEF35fAoFAqFQqFo9iiHRyEdPz8/2Sa0WJT2clC6y0NpLwdr0F05PArpGI1G2Sa0WJT2clC6y0NpLwdr0F05PArpHDlyRLYJLRalvRyU7vJQ2svBGnRXDo9CoVAoFIpmj3J4FNIJCwuTbUKLRWkvB6W7PJT2crAG3ZXDo5DOuXPnZJvQYlHay0HpLg+lvRysQXfl8CikYw3/CC0Vpb0clO7yUNrLwRp0b1CH559//mHMmDEEBgZiMBhYsWKFxX4hBLNnzyYwMBBnZ2eGDBlCbGysRZ2CggIee+wxfH19cXV1ZezYsSQkJFjUSUtLY/z48RiNRoxGI+PHjyc9Pb0hb01Rj9jYKL9bFkp7OSjd5aG0l4M16N6gFuTk5NCzZ08WLVpU6f7XX3+dN998k0WLFhEdHU1AQADDhw8nKytLrzNt2jSWL1/ON998w8aNG8nOzua6666jpKREr3PnnXcSExPDqlWrWLVqFTExMYwfP74hb01Rj0RFRck2ocWitJeD0l0eSns5WIXuopEAxPLly/Vtk8kkAgICxKuvvqqX5efnC6PRKJYsWSKEECI9PV3Y29uLb775Rq9z+vRpYWNjI1atWiWEEOLAgQMCEFu3btXrbNmyRQDi4MGDtbYvIyNDACIjI+Nib1FxkWzfvl22CS0Wpb0clO7yUNrLoSF1r+33t7Q+pvj4eJKSkhgxYoRe5ujoyODBg9m8eTMAO3fupKioyKJOYGAgERERep0tW7ZgNBrp37+/Xueyyy7DaDTqdSqjoKCAzMxMi5dCDiaTSbYJLRalvRyU7vJQ2svBGnS3k3XhpKQkAPz9/S3K/f39OXHihF7HwcEBLy+vCnXMxyclJVWastrPz0+vUxnz5s3jxRdfrFC+Y8cOXF1d6d27N3FxceTl5eHu7k5ISAh79+4FoF27dphMJk6dOgVAZGQkR48eJTs7G1dXVzp37szu3bsBCAoKwtbWVr+nHj16cPz4cTIzM3FycqJbt27s3LkT0Jw5Jycn/v33XwAiIiJISEggPT0dBwcHIiMj2b59OwABAQG4ublx9OhRAMLDwzl79iypqanY2dnRp08ftm/fjhCCVq1a4eXlxeHDhwHo0qULqamppKSkYGNjQ1RUFDt27KCkpAQfHx/8/PyIi4sDIDQ0lMzMTM6ePQtA//792bVrF0VFRXh5eREYGKjHXXXs2JHc3FzOnDkDQN++fdm/fz/5+fkYjUbatm3Lvn37AGjfvj3FxcUkJCSQk5NDUVERBw8eJDc3Fzc3Nzp27MiePXsAaNu2LQAnT54EoGfPnhw7dozs7GxcXFwICwtj165dut52dnYcP34cgO7du3Py5EkyMjJwcnIiIiKCHTt2ANC6dWtcXFw4duwYAN26dSMxMZG0tDTs7e3p3bu3vuCdv78/Hh4eevKs8PBwkpOTOX/+PLa2tvTt25fo6GhMJhOtWrXC29ubQ4cOAdC5c2fS0tJISUnBYDDQr18/du7cSXFxMd7e3vj7++t6d+rUiezsbL3t9uvXj5iYGAoLC/H09CQoKIj9+/cD0KFDB/Lz80lMTASgT58+xMbGkp+fj4eHB+3bt7dosyUlJXr8W69evTh8+DA5OTnExsbSqVMnYmJiAAgODsbGxsaizcbHx5OVlYWzszPh4eG63m3atMHBwYH4+Hhd71OnTpGeno6joyM9evQgOjpab7Ourq663l27diUpKYnU1NQKevv5+WE0GnW9w8LCOHfuHOfOndPbrFlvX19ffH19OXjwoN5mMzIySE5OrtBmvb29CQgI4MCBA3qbzcnJ0fWOiopi7969FBQU4OnpSXBwsN5mQ0JCKCws5PTp0wCX9Izw9PTU71U9I2p+Rpj1ro9nhL29PWfPnlXPiDo8I9zc3C75GZGTk8O2bdsa5BmRk5NDbTAIIUStal4iBoOB5cuXM27cOAA2b97M5ZdfTmJiIq1bt9brTZw4kVOnTrFq1Sq++uor7rvvPgoKCizONXz4cDp27MiSJUuYO3cun3/+ud5wzISGhvLAAw/wzDPPVGpPQUGBxXkzMzMJDg6ucXl5Rf2TkZFhFWnHWyJKezko3eWhtJdDQ+qemZmJ0Wis8ftb2pBWQEAAQIVemOTkZL3XJyAggMLCQtLS0qqtY/5lUZ6UlJQKvUflcXR0xMPDw+KlkIP5l7mi8VHay0HpLg+lvRysQXdpDk9ISAgBAQGsWbNGLyssLGT9+vUMHDgQ0Lrf7O3tLeqcOXOG/fv363UGDBhARkaG3o0LsG3bNjIyMvQ6CoVCoVAoWjYNGsOTnZ2tjx+DFqgcExODt7c3bdu2Zdq0acydO5fQ0FBCQ0OZO3cuLi4u3HnnnYC2uuoDDzzAjBkz8PHxwdvbmyeeeILu3bszbNgwQBsnHTVqFBMnTuSDDz4A4KGHHuK6666jS5cuDXl7inoiNDRUtgktFqW9HJTu8lDay8EadG9Qh2fHjh0MHTpU354+fToA9957L0uXLuWpp54iLy+PRx99lLS0NPr378/q1atxd3fXj1m4cCF2dnbceuut5OXlcfXVV7N06VJsbW31OsuWLWPq1Kn6bK6xY8dWmftHYX1kZGTg7e0t24wWidJeDkp3eSjt5WANujda0LK1U9ugJ0X9s23bNou0AorGQ2kvB6W7PJT2cmhI3a0+aFmhUCgUCoWisVA9PKWoHh6FQqFQKJoeqodH0WQwJ6hSND5Kezko3eWhtJeDNeiuHB6FdIqKimSb0GJR2stB6S4Ppb0crEF35fAopCM7cr8lo7SXg9JdHkp7OViD7srhUUjHnHVb0fgo7eWgdJeH0l4O1qC7cngU0jEv5KhofJT2clC6y0NpLwdr0F05PAqFQqFQKJo9yuFRSKdjx46yTWixKO3loHSXh9JeDtagu3J4FNLJycmRbUKLRWkvB6W7PJT2crAG3ZXDo5BOUlKSbBNaLEp7OSjd5aG0l4M16K4cHoVCoVAoFM0etbREKWppCXmYTCZsbJTvLQOlvRyU7vJQ2suhIXVXS0somgx79+6VbUKLRWkvB6W7PJT2crAG3ZXDo5BOQUGBbBNaLEp7OSjd5aG0l4M16K4cHkWjIISg2FRc6T5PT8/GNUaho7SXg9JdHkp7OViD7srhUTQKD//6MPYv2Ve6Lzg4uJGtadpkZcHRo2AyXfq5lPZyULrLQ2kvB2vQXTk8zYiM/Azyi/Nlm1EpH+76sMp9+/bta0RLrIeiInjoIbj5ZsvXTz9Vf9zVV0NoKCxadOk2tFTtZaN0l4fSXg7WoLtyeJoRnq95MvTzobLNqBQHWwcAWi9ozbwN8yRbYx0cPQoffQSnT0N2tvb65x9YurT6406d0t7Pnm1wExUKhaLZYCfbAEX9YM4usDVhq2RLKsehsIRCW0jKTuLZv59l5qCZ+r6QkBCJljUs2dlw++2QkVFxX1aW9v7ppxAern2+/XY4d676c5pj//LyLt2+5qy9NaN0l4fSXg7WoLtyeJoJp7NO65/zivJwtneWaE1Fsm1LqtxXWFhosT1vwzz+TfuXj8Z+1NBmNThxcbByJYwdC5XF7A0dqg1PmXF3h19+gd69qz5nerr2nl8Po5cXaq9oHJTu8lDay8EadFcOTzPhidVP6J8n/jKRL2/8UqI1deP06dMEBQXp28/+/SwAHbw6MH3AdBztHC3qG140YMCArY0tp6efxs/Vr1HtrQ3vvqvF2OTmatuLFkFtYvYeeggcHKqvM2gQLF8Oy5bBX3+VlbdrB6tWwYW5vVJTITERIiIqnutC7RWNg9JdHkp7OViD7srhaSZ8G/ut/vl/B/5ndQ6Pf46Bs65lSb2FEBgMhgr1Dp8/rH9+9u9n2XlmJ9/f+r3FcQACbZr7gE8GcGzqsQa0/OL4808oKYE77gA/P6jt/3lUlPaqidGjLZ2dI0dgxQrIzKzYk3TFFVpPk8qprlAoWjLK4WkGfLv/W4vtwpJCdibupE9gH0kWWZJTmGPh7ADkFOXg5uAGQO9y4zcLtyy0qPdD3A+YhAkbg9ZtsenUJov9JzNONoTJl0xODvTpA6+/3jDnHzlSe5lZvVpzeN54A4xGy7pxcVWfp3d1Y2eKBkPpLg+lvRysQXc1S6sJU2Iq4c0tb3L7D7dX2PfqplclWFQ5yTnJ+ufg0uDdzIJMvSyu3Dfykp1LKhw/5usx+meTsEw+88zlz9SXmfXCb7/BrFlw+DC4ujbedcPCtF6kxYvh1VctX9URV503pGgwlO7yUNrLwRp0Vw5PE+bb2G+ZsXqGvt2/TX/98/cHvq/sECkUlmjBav98Cl/+qJVtOrmJP47+AUBeDdONfjvyG2eztTnYOYU5Fvte3vAybRe2rWeLL54ZM2BhaSfVFVc03nXbttWmq6emVnwtKfUhv/mm4nE1aa9oGJTu8lDay8EadFcOTxMlMSuRu368y6IsITOB3Q/u0Ldv+u6mxjarUrLOaTPIXIvAo3RK9a3f38qoZaP4POZzTpdo+0tMVc/keurPpwAY/dXoCvtOZZ6yiP2RSW4uPP44nDwJ998v2xqNvn219yeeqLjP3d29cY1RAEp3mSjt5WANuiuHp4lyz/J7KpQVnzlNZFBfwjw6AvBj3I9674pMxv58BwAufm3w6DfIYt+EnyZw0xrNMcso0Ma7Xu8wiec8ruPn23/W6y3bu4wVB1fo29sf3G5xni6LulS5VldjkpcHztaVEYA+feCVV6CyWaHWkBujJaJ0l4fSXg7WoLtyeKyN2NiyVLrVICgLAj74rvZ+1q10O7Ns1tLqY6vr1byL4UyeFsPjsuBt3B+ZVmW9mKQYAHrP+oCXp//KmPy2PHv5TOxt7CkRJdzw7Q163ag2UbRxb2Nx/H0/3VfvtleHyQQxMRAdXfbKyQEnp0Y1o1Y4O5dNkS/P3r17G98YhdJdIkp7OViD7srhsSaKirRkKW2rj0k5l3uOv+P/1rcDsyz3G8slpLO3qXzBzsYiKTtJ/+zq5o2Hp3+Vdedvng+AvzlMJzKSV37OpshUZFGvn9co1q2DIIceFuVf7m24qfiZmXDTTXDNNbB7t1b2/ffQqxf061f2ys0FX98GM+OicXHRnLG1a2VbolAoFHJQDo818ccfZZ+F0NYQMBjgvfcsqrV6o5X++Y3V4FLqD3RK9OA0gSS/AXtbzwFg1dFV/LR9J8MX3c83G7dx6NyhRh36ab2gtf7Zx6sNjl5VewO/H/0dgIjkcoXvvsvAoIEW9ba/M42hQ2Hbsx8z1v1FogLLEtdcGNRcX+zfDz/+qCX2W7ZMy57855/g5qb18phf+/fD3Xc3iAmXxLBh2vtvv1mWt2vXrvGNUSjdJaK0l4M16K4cHivCNHYMhtlgmI3WpfDVV9qOKVOqPOaJzWC7/h8G/n4LR7+J5WGW4FACEW98DsB/9/6Xcb/35c/zn3HHX5cR9l4Ys9fNJrcol2H/HUZ8Wnyt7Tt8GL791vK1Z0/tjp2xGW2sx8NDL8t5pWz/Rzu1ZSTap1U8tkeKZTO979QJjvhchle2M5ftuIEtQ5fp+46nH6/t7VRJUZG2Ynn5+1y5smz/ggVw3XXawp+hodCzZ9mrW7eKmY6tgY4doXv3snW4zJhMpsoPUDQoSnd5KO3lYA26q8SDVsTp8kHsp0/DAw9UqFM+D830zaUfunWj3bZxbCaIFBIAMBw9Rju3IBwdXUjNS7U4x+Idi1nz7xq2n95Oh3c6IGbVLgXvAw/Axo2WZZ06aVl+ayLFBS0FcDlvwKUIeifCrsCy3p1pm+z5ouscig6Uzbrq/ZwJXii7cPvCBDqd34Y7meR+vQLbr1/gVMYpghcGs2DLAj69/tNa3U9V/P03jBtXsdzLS8utk5AAt94Kb79d+fpY1oqjY8X1t06dOkVgYKAcg1owSnd5KO3lYA26W+Fv0ZbLsHITrwrfe8dyLYAibdzqf39pEcrPxxhZYI5HdnOjEG0Bph22lxFgd44AznD6mHul07VT81LZfrpsllNKTkqNtnV+tzMbhxlgtoHMTK0D6v/+r2zFbzPFpmJWHta6Q8pPM590yE3r3XF1pX0aTC69/A/fae/LDy4H4GBBFPcceIYH+FR/PWRaCrPLtOjKAQDcyeJNphPAGfq00dILfxbzGQEBWLzGlOUtrBXmlc0TEtDvNTMTkpK0GU8AAwZo57bGAOWqcHKqnwVHFQqFoimiHB4r4nC58JbErz4gzUkb3hp1N9pqlA4O2B3SulMeHv+25hAJAfb2FBoc6RaUwYsvwpTihUxhEcX+ZZkth7W5gaq46r9XVWvXU0/BkdSybhwbxxzc3bUlDHKLclget1zf9+aWN7nu6+u48rMr9Wnm//sOBo6aCMB1Ywzc9vY8Ovz2H+bxDF+nW2ZKPhH7JG7OxZgie2Oa8zImDNrLtaz762Z+AGAh/2Em85jCIh7Lfk3fP2VK2atv37oH6przY/n5aauXm18ODtqinSYTTJtWt3NaAy4u2iiptzds2KCVRUZGSrWppaJ0l4fSXg7WoLsa0rJS9vjD/tJFwP/ohJbCF0i30YIwAkbcWFbZYKBg+BjCPeC554DnteCY/yvd7efqx8yrp/Dnf8sck/KUz9BsJiM/gzc2v8HVIVezfftQGFq2z/t1bwqeL8DJCXIGzOTG797l2CNniD6zlaf/fBqADSc36EtKeOajTRFCi4VZiebk+HAOAwL7+I0UhWzE/sjVRJsuZ9hIWwzLd2kX+993sG8f5GSz4A/4+ebuwD4AhvMnw/lTt8t8v7c9coRQn1AAPvlEu2Z2dtlomsFQMVfOuXNabHhREezaBXZ2YF/JBLdK1jttMrz6KqxfD08+qUk6aBAcPXqUbt26yTatxaF0l4fSXg7WoHuzcnjef/993njjDc6cOUO3bt146623GDRoUM0Hlufff6EhPVHzMJX523fTJhg4EBISuHU/xLd2Itonn2mj4LhX2WHv9oOpo+GN7HN45MP5HDfmzylLJnfgAFx5ZWnl2bO1Vylf3fgVEX4RFUxZ+bGRV6/K5XenlRh2G9h772kCXLUx1qfWz2Rp7GJe2fAKPdMtY3wKSwopKC7Aw8MRU5Q2xNZxcesK5w9/LxyAf13cSbn3CSg3cmZDCcn7U7CJ6MqONRD1ENxQ8Bff4gfLy11v717dy5i+BaZv2Ve2z95eH+orT36xNm6TkpPCC8lXgOEA7u62FnU+/BAmTiynxUpNsnbttMuNGlXhtE2eXr2018svw9dfa0HoSUneBARUfUzXrvDQQ41nY0shOztbtgktFqW9HKxB92YzpPXtt98ybdo0nnvuOXbv3s2gQYO45pprOHmybqtpfzB9cFkQR0Nw/fWW03guv1wbrnr8cQrsoFWXXgCMOmp52LulnTCpuefxKbRl1R8G3ngD1qzRpkcbjXD11aWVZ82CvDwCSuNrru5wNa1cWlmecLbg2oR0Nni2JTFfy5XT46qD+PlpQzlLvyhLy7vnUDqOwsPi8ITMBK67/oIpP1Uw6fBp/C4Pxc+vrOzWG4qx6RYOwcE4ls6Sdy2ibCGq8oSHVyz75x8tsCY6Gj74AIDHt2q7eizpgUmYGPTZIBILD/PoB/9l2TL0V0BAxUDrnBytV+f4cYiPh19+0Ry7hprmLpObb4a0NK3d7NzpxZ9/Uunr22/hP/+RbW3zxLUxV5ZVWKC0l4M16G4QQtRuio6V079/f3r37s3ixYv1svDwcMaNG8e8efNqPD4zMxOj0ciAu2DzMiAuTluCur7IydF6JBwdq6wy+i5wuvZ6lh/+SS+7IvhyNp7ahGcepDtDYJETifb5vOsjmDGj4jTj8qS6GMgddTVB8z+EDh0wvKj1lExdEcnVMcEAXD/7F71+G8cuvN/1IAA/xs/i83Qtl8874XuZGteD969awKN/z6AmBn3zHzbcXua4rDBFY+ijLehkZwdXXVUu2HftWgqHX8VdN8L81dBu/kfw4IMXCDMafv/dsuzCZvvAA+R+8Smuz2mbY7uM5edDZUtTlJ+JFhmp+Znl0xstWABz5mi+7qmMU3y17yue+UsbevvvuP8yvuf4Gu+7KVJYWIiDg0Ol+z74AB59FIqLm/ZQnjVSne6KhkVpL4eG1N38/Z2RkYGHh0eV9ZpFD09hYSE7d+5kxIgRFuUjRoxg8+bNlR5TUFBAZmamxQvQexsID4eSqhezrDNubtU6OwCFtuBg74S3fdkf7OautwCaswOQaK8N17z/vnbK6vAOCiVo+V9aEpYBAwC49jC8HRPD2OsEY4+9xYNnyqYJni44hEPXVYwdC14n/qeXT43TMhofmDeDQ1MOVXvNLj//B/uD1+KYqUVg25YYuL5/MmPHwtixmu9iMbNp8GAcSuB//4N2GcANlQRX//ij5XZlPvr8+bgUwfe/a8HN5Z2dC3F11XpwzDaNHQsffwxOzib2JO1h/PLxurMD8NvR36o8V1NntzltdCU4OWkB2sXylyhrdlSnu6JhUdrLwRp0bxYxPOfOnaOkpAR/f8tlC/z9/UlKSqr0mHnz5vHiiy9WKD/p4AVo2e/O3XMPx6ZOxd3dnZCQEH0tkHbt2mEymThVuuZVZGQkR48eJTs7G1dXVzp37qz/cYOCgrC1saGaMAmdAjswFZkY3/E+3j74NgAueS4WdRyzPeHUZbRpk8v118O2bVpMS3h4OGfPniU1NRU7Ozv69OlDjsGA3om4dSvn9oBb6UjVv2+/TUpKCg+szeDjO8vO//aGt4nyieItYxwXcl8MBDj6VGm/mA2wkG1bb6P/ZefMpWzb4o3x4EHatm3Lvn2ave3bt6e4uJiEhATMIdNZAwZw4OhR3JKS6NixI3tKsxq2bdsWm5gY/Etjq/Lz8zl27BjZ2dm4uLgQFhbGrsOH6Q8EJ1wwT76Ubdu24eTkREREBFdddZx167zJy3PE1taWnJxcfH3BeNsLRH6wqMKx2WnZHD9+HA8PD46UjoWFh4eTnJzM+fPnsbW1pW/fvkRHR2MymWjVqhXe3t4cOqQ5h507dyYtLY2UlBQMBgP9+vVj586dFBcX4+3tjb+/P3Fxmt6dOnUiOztbb7f9+vUjJiaGwsJCPD09CQoKYv/+/QB06NCB/Px8EhMTAejTpw+xsbHk5+fj4eFB+/btLdpsSUkJCQlanqZevXpx+PBh0tLSiI2NpVOnTsTExAAQHByMjY0Np05lAaGkp+eRkhJPVlYWzs7OhIeHs2uXFlTepk0bHBwciI/XElh2796dU6dOkZ6ejqOjIz169CA6OhqAgIAAXF1dOXZMW+uta9euJCUlkZqair29Pb1792bbtm0A+Pn5YTQadb3DwsI4d+4c586dw8bGhqioKF1vX19ffH19OXhQ650MDQ0lIyOD5GQtaL5///7s2rWLoqIivL29CQgI4MABLbVBx44dycnJ0fWOiopi7969FBQU4OnpSXBwsN5mQ0JCKCws5PTp0wD07t2buLg48vLy6vyMMJlM+r0GBQVha2vLiRMnAOjRowfHjx8nMzMTJycnunXrxs6dOwEIDAzEycmJf//9F4CIiAgSEhJIT0/HwcGByMhItm/fruvt5ubG0aNH9TZ74TNi+/btCCFo1aoVXl5eHD6spbHo0qULqamppKSk6Hrv2LGDkpISfHx88PPz09tsaGgomZmZnD17toLeXl5eBAYGEhsbq+udm5vLmTNnAOjbty/79+8nPz8fo9FY5TPCrPfBgwfJzc3Fzc2twjMC0EMYevbsWfEZUdpm8/LyOHv2LMePH9fb7MmTJ8nIyNCfETt27ACgdevWuLi46G22W7duJCYmkpaWVqHN+vv7X/Qzwt29Czt35pKRkYHBYKB//zAMBut4RuTk5ODm5lbpM6J8m42Pr/4ZkZaWxrZt2xrkGZGTU7vQg2YxpJWYmEibNm3YvHkzA0p7MgBeeeUVvvjiC/1BWJ6CggIKyo0HZWZmEhwcTOSYjsyNO8Y15hia1FQt41wtyc/XEtcVF2udKq1aAS+9BC+8UFbpt9+0IIk33ywre+89+hYuonfHK+gb2JdJv04C4ODkg4S9Zzm05pLhTc6b52s2pqpxiLfegscfByDd2YDXM+CfXW7x0UquCWCaDYarr8Yw6C+L8uf+gZfNS3v16qVNc8rIKMvKV0MTS/npJ1qNG6cFl/zvf1VXNN9PVeczGEhyg9ZPWBY72jqS/3zNCWjMQ34X8vLQl3nuyudqPL4pcvr0adq0aVPpvhUrtA63l18unf1XDiG0dm4yaUOUtraVnkJRBdXprmhYrFH7oUNh3TrLsvh4aN9ehjUNQ0Pq3qKGtHx9fbG1ta3Qm5OcnFyh18eMo6MjHh4eFi+AmG7HGH03HDP7ON7etVq93Mx338G112qxyc8/X1pYztn5qDf8x7Cab++L4sS0CXp50aSJ7MyI4+tfE5kzq2w+dGefzhWukWtMrVBWJ8aO1T96PjyNtFchcQEMOAXXu/Xljc1v6PtfKefbGAD+KivwctJEsiufMdw8hGg0ammZf/mFmjCYG2hNQW133ln9fsCvEke/fHbquvDClS/Q2q11o6491tjYVuOpXHGF9r5+fcV9u3dr63ONGFEx+7aiZqrTXdGwWKP2qakwfrw2Sfin0hDO9HSpJtU71qB7s3B4HBwc6NOnD2vWrLEoX7NmDQMHDqziqOq54v5yf5waVi8H7Qvgo4+073dPTxg8WJsJY4HJxENj4a1tb3H7D3fQ3nMpTw8DfvuN3UnaEFhJoSM5hzSbX2i1l48/rtjr4O3sXbebSU62jG72KTcs9eCDeOaDjQCfXPgpewef7P4EgMe2wcwNUPKiebjKksf6PQZcEPdUPkDn8su1Radq4Lh5anlNDs2yZVqXQjXYVNL5U2QqosRUwvnc83y6+1MMLxrILMi0qJNdWHHK5ItDX8TB1oHfj/5OM+gIrRRzl3Rl+PpqD+HKsjOfL9fBmJxccb+Zs2e1NbxCQur+qiycqzqys2HLlrodI4vqdFc0LNaofV4e+Ptr7b5DB60sIUHLI/bRR1qneVPHGnRvFjE8ANOnT2f8+PH07duXAQMG8OGHH3Ly5EkefvjhizpfiXsnoPoA3fI89BCUDvty9dVaQHFODnra3mvuggH/vFThuNevgKWxE/A/rvVEDcyaT9tBIXw2WzDHXGm25TE1BQ5bGLVtW+m4WjnKd/mZ+0xHj+bXLpbBue+UTowymL/rH3kEFi/m8DtwYsvvvLRZm/123BMtcc2FM6lqSYnRWOOwl05104W+/BLuvhuXQsh1gPl/wBl3WDAQ7F6ybOoTf5nItzd/C8DqY6t5d/u7Fvt/vFULlD6RcYITGSf4LvY7bou4rfY31Uy4cDmKFSu0qfv7yqVDuv9+bTYXQFCQlinArlTuAwe0FeQnT67bumO7dsGvv2rNorYzxCZMgB9+0Hzi6o7JyoKoKM1pc3DQ7ikqqva2KRT1TV5eWTJU89yWt94q61Dv21f7v1JcGs3G4bnttts4f/48c+bM4cyZM0RERPDbb79d9JL0DiZv6NIFDh3S3O4qSE/XktgdO6bFObz8slZ+zz3a96+L0Q7IIS/UlVXrZlV6juScZD0rsbdNCJ9+Cp9arH95kb0LpflpqsXVtczZqCyG5Ztv4Pbbtc8RWvLC0FQI9YhkTZvL+OfEP1zeayzM+anisbWkR48eF32sBXfeCXffTepr8GtnuCkO/g7RHJ4L+S72O0Z3Gs0Nnccy8suRFfaP6nEjFJXpfiztWP3YaGXUpL2zc9lSG0VFcOONmpNgb6916D3/PJh/uB04oLX5jAytE/H117X11kD7v6iLw7NsmeY/v/himfNUEz9oK46QnV39DMbjx7V/61L/nQMHGt/hqbc2r6gz1qh9eYfH3Em+dy/06KH9lrxwompTxBp0bzYOD8Cjjz7Ko+afmpfIaZstFP+VhN3TM7RA2ip+av72Gzz9NLRuDZddVlb+f/8HUTY74PPP+Tf4DG/V8roXLnlQrwwcqI1R1II3VqMlRLztNu1b7NdftSXCJ0/WKrRuzWvAawCze1+SWcePHye8suSCdcVggJUrcbz2Wm4qnWR2VTy4FkJOJekfJvw0gQkXlJ19A/b5gXMxWgbG0ttta6x5WLMpUpP2Tk6Qm6v1ipw/r/0bfP115cNNf/yhNZWcHM3h2bFD656vq7MD2oO+bVtYsqRux4FlB2Z1zJih/SaQsaBqvbV5RZ2xRu3LOzytWmnDwMnJ2oQANzdt4eKZM7XFi2++Wa6tF4s16N6sHJ764Nc7f+W6H7W4k1XHc7juxhu1n5vnzlUcGkJfIorTpy39odBQCP1c+9loeMDymN8Gn2f0+orTux3P9S1bHqIh2LSp2t2Zc8HjWQjIgv9sATZN0Xb8+CNs3aoFdcTFVcx8XFNCoBow50CqFyqJt6rM2akM71wt6Pnq+NKClBReXQPPDNfWFmuO1KS90agFUpZ3Inx9K69rjjl/7jnNwdm+XeuKv+mmutvVvXtZz1FtKSzUennMPVLV4eWlOWNOTtUn72wo6rXNK+pEQ2sfHw9vv22Zxq1dO3jiicrrv/ee9qOifA9P6UxxQJvQGxioOefu7k3X4bGGNq8cngsY1G4Qwa4dOZVzjLNZKWCeRrd+faUtzdxQaxNnsOzGZXT26UzfQG+iO0cT9VFZP/rByQfxd/PH06maEzQw7oUQsxi6nAfb8qNo9vbaSpOgRdZdiItLxbI64ORUjzcdHHzRh6ZWchtPb4K5V9nr63M1N2rS/tFHNefdHCvu4qJ1FFZGWJi2z/ywNhq1RJONhYMD3HFH3Y5xdNR+rBw9Wvl+d3etyQuhDa9duFKNqyvMm1fm8xcXa0NmZtq3r3xIrl7bvKJONLT2334LixaBeZ3MzEytTYwYoUUFlF9ZSAiYUvq7sl+/ys83bJg2BPvyy1qne1PFGtq8cngq4d1B/2Pcqt4UF9lCuyCtcMYMC4fnl1+07vuDB6v4vi/9mVlSzhG6s3vZLKS+gX2Zd/U8Zv41k8iASLr4dmmIW6kbQUH0LE06xccfV16nspxEN95YsawO1OsKukZjnQ957oAvr3Q9V+V+Z1vHZuvw1KS9pyfcckvtzuXrW2MnotXh5aXFGr3+euX7bWy0niZXV83h6dJFy1QBWs/Qrl1aD9aQIVrZ88/Da6+VHf/UU5bbZmrT5t98U5tzAFqeo+ee0xyw557TRpprMQFSUQn19bz56Sf46quK5fv2aWGfpTkR2b4d+veHnj3hnXfg4Ydh6lRtKro5i/l332kpzKrD0VFOb2R9IXuldGgm09LrG1dnLQ9ObkER+lLSF/y0+/BDLVGUvz9MmlTJSc5pX6C7ShcRH9S24qrtvVtrsS+fjv20wj4pmH/m3nqrNvWmJubP136iVJHrqLaYs8g2CE8/zblPfFn+TdVVOoaX67L473815zYmRgvKatUKJ2xJyk5iym9Tmp3j06DaNwH++gvWrq389eWXWs/WbbeVDcstXqylmtq8uWxS4vbtZWU7d2pxFmvXal9wpQmFK1Ab3efN09JdpKXB999rYXR//63Z9dFH9SRAC6S+2vwHH2jfAWlplq+gIG2CrJmoKM1xDQrSUrodParFph0/rsXGjRmjr/xTLU3d4bGGZ43q4akEFydNlvmfx/LTogHgul0L1hlSVicmBm4YmctnHxVXHiX52GOcNEK/0oa/aHTFJQtGdBxB0owk/N0uzWGoNxwdtUg5b+/ajdFNmNDgJl0Ur72mRZLHxUFoKD6vvcY4YNFKiEqE/hMtq9912ytEDPuZjuPug1njywK7t2yBdu3ILc5kUbT29xvSfgg3d22ig+iKCrRvX3U22+Ji7Qut9LcLd90FvcvF53t6aj0/Tz9tedx992k9Pq1bl8X41YUPPtACw8+f14YxJk3SYkCyssp6k2sTp6SofxYt0pxP0JzRm2/WcuVUh8GgDVf5+2vhoOap5kuXVgyHrA6zw7N6dcV9/frVfWJAfWPWxsdH6/mqYelIKSiHpxKc3LSnSWLfiVx19EEo8IKtB8HmtPbUCQsjOBju+3IU7E6C0vVnLPjpJ9rNLtuM8Iuo9FpW4+yYqSQwuwLR0Zoz4VMx8PpiCAwMrLlSXXjqKa3f+AJHdHJpHosOqVqM0hEfLbmiw6wIok5XMfX/5ElSyv2XVJagsClT79o3I+zsqu9JcXDQArrLJ2GEsiwWrq6wZk3lU94LC3thXjh6/HhtiMPMt99qw2gTJmhTkkEbyvr447J4oM2btfMaDFoidzW8VXsupc1/8YXWi9O/vxYueN99tT/2P/+BVau0z5dfrsXG1YXWrbUO9ZEVs2jw+ONa3p7GICND68E0ZzNxd9dyz33xhfZVmJ6uDYhceH/W8KxRDk8ltPEo+8NkX3cDP7g/iM2198Da0sIfTmjBzF9ugCNo0z1KF/MjKwvefZe4C2ay2Bia0ehh377aq55okGC2auYmHxrzB9jYIBJOYXvbZVXWM+NYrC3sCs1vtpY1BBI2Zfz8tFdlTJ5c9Yy2vLwSnJ21X/s//WTp8OTmatORy/ccPP982VpLhYXoztL332vpAJTDU3tqavNffAFz51a+799/Ydq0yuOyauKuu7TXxTJ2LCQmavmwynPzzZoTduoUjBuntR/Q5pl8+OHFX68q3noLZs+2LDMatV7HIUO0HqhvvtGCtPv3L6tjDc8a5fBUQvlelxUHVzCjrQMLy1e4MJlhfHxZtrPSL9qus8t2m164uLWcWgr//vsvrWrTs3SxmEzazxFbW3B3x27YiDodHnYO9pSGcq08spLHL3u8AYyUQ4Nr34IZOlR7Vca2bXvp378/Dz2kDY+XJy+v4kSI228vy/9ZnthYLeD17bctZ/8oqqamNv/HH9pQZGXB+gZD7cIbG4rWrSuWeXpqTs6+fVoQ/aRJWjLN5cvr1+FJTtaykq9dq+XJWrtWcwCjorRenzvv1Jz8zZu1Xsf337eMYbOGZ41yeKrgz/F/MuyLYQC8dfI7S4enMo4ehTZtSHaFsRdMjTXUNje+omEwGLTXH39A54qLsVbLhAkM+3ep7vCs+XdN9fUVijrg4aEFOptnfoE2JHDNNbU7PiBAW7x1924tWFpxcdxxh/Z4AK2TfuxYWLBArk21xcVFc3y//lrbXrBAiw+aNq3sHlxc4IEHynoGL4bFi7WeHVtb7Vze3pZB1E89pQXqp6VpuYWefLJuS8M0BsrhqYKrO1ytf7Yz2AIlVVcGbY7h/ffT4XHLRHcvD325YQxsRkREVB7fVO+MqFvPDgCffcZL3t9jGNyXPcH2rPl3DSZhqrchytc3vc6mU5v46faLX5rjUmg07RUWmHWfMqUsz48Zg0GbKFkb3nhDG9ZKSSmb4mzGxkb1+lRGZW1+82YtIN38iKitw2kNREVpw52Jido9uLhojoenJ7z0kpYAMTtbS+Z5xRV1O3dSkhY7VlKizUrs2dOyR9LHBzp10nqYzAMfdnbaMG9RkRa4bHZ4vL2jqpy12FgYRHNdBrqOZGZmYjQaycjIwKN0WOqTXZ/w4C8P4uPsw7mkezTXf8AAzb01s2eP1gqCg+HUKR4YC5+Wm8lxctpJgo0XnwyvJXDo0CG6dLGCPERV4e8Pjz/OzzdFcP0313PksSN08u50yac9m32WgAVa19EdEXcQkxTDgckHLvm8dcHqtW+m1JfuGRlVz84JC9PmFigsqUx7Pz+tR+TZZ+XY1JAkJGhfT7//XhYEX1veegumTy8bSrvjDi0bSU3k5GgztQoLy8rS05N47rmAuhlQSyr7/q4M1cNTDQ/0fgA7Gzsm/DSBvNdewdm+NPf3zz9rkYaA6N6dEhuwO3UK0Gb+lEc5OzWTnp4u24TqcXKCvDxc7LXAijc2vcEHY2pemPX5v5/nlQ2vALD5/s0MCLZMtnHofNmq91/v/7oeDa49Vq99M6W+dDcataGYC385b9igBT0XF9d+8VVrIT4eFi7UZv/MmaMNodQnF2qfkqJ9QV9iwnirxbxkxcWkMvjxR21+TunXW61xdYWJF6T/2LbtBNAwDk9taWL/Co1PkIeWaTkhM4FQn9J5ditWaD+tkpN5ZcMr/N8LYJoNh3xhQ7l45g33bWh0e5siDpcysNwY2NhAejpD22sRqAFuARSVFGFva1/lIY///jjvbH9H337272dZe+9aizqDlw6ucFxN561vrF77Zkp96l7ZSK2bm+bw3HOPtjIMaEMLkyc3/srwdeXHH8uWULjnHi27NWiJ+l5+Wft3fOABy54tJ6eKc0mqorz269aVBZbLzmPTUJgdudmztVlcdYmpSUiovwWtreFZoxyeGmjtrvXlTV01ld/v+r1sh9EIRiM/rdN6elJcoVe5jMtGRyNXtK3jgGkLJTIyUrYJ1XP8OCxahC2AL8z5Zw5vbn2TrJlZVR5S3tkBWHd8ncV2VSPJZ7LPNOrK7FavfTOloXWPitLWYCr/y3zXLu1L3dodnqxy/1blg2JXrSqbql9ZfqR//ilb8q88ubnaEkBmhIhk1y7ts3mq/+rVNOzCzRJxctJyQ+3dW/0QaGUUFZXlYb1UrOFZoxyeGujso83qWXV0VYV970e/z64z2n/O5mDIL/0l9d7o97ir+yUkXGhhbN++nf7lEzZYK4sWwWztY10TEJqXETGTVVi5s3Q683SjOjxNRvtmRkPr3ratlvSwPAMGaMGr1sjRo1pivqIibaFMM/nlVnLJztZ6G8xDM//8U1ZnxAitN6IyZszQlnIow7KLIzAQhg+/5FuwWgwG7f5HjtRWXq9uJaD27S3XXy4oqL+MydbwrFEOTw3Y2VQt0eTfJuufbyiXI+OBXg/gaGeFebUVF0eXLpZP4VLyi/NxsquYTCs+Lb5CWVZBFrlFubjOdWXe1fMwlD50f7j1B2767ia9XkJmFU9theIScXPTQg8vbMpjxmhTimWycaO2VtiNN2rT66+/XsstVL6HJytLmxWUkKAtyWDuzTGn2DLnfjHj6Kj1CCUna87eotLVffbt20f37t31epXltmlumJ2YmhYC7ty5osNpBfkC6w3l8NSC14e9ztN/Po0QQs+pcyCl8tk0V4dcrZydOhIQIDeQrUaGDKnU4SksKazU4Xnmr2f0z2M6j+GXw7+QnJPMbd/fBsDMv2bq+y/szbn1+1sR3Rpv4qTVa99MkaH7lClafEx5tm7VEhc2tsMzebLm2JiT+OXlaU7LDz9o2ydPag7P/fdrwcsAp09rDs/585b5ZAwGeOUVLdmemeJibZbQ9u3auQMCytZB8/HxqHW8T3MhPFxzFKtb2+2rr7Rp7OXXi8vKqr8eHmt41iiHpxa092yPQGAzR0tqkftsLvM3Vz4376/4vxrTtGaBm5ubbBOq59VXtafphg3MLOjHPMftABSbiiut/l3sdwCsumsVwzsOZ9H2RTy+6nF+Pfxrhbrezt5sf3A7//njP2w6tQmAI+ePlAXINzBWr30zRYbu11+vvcrz2GNlQ0ONibknprzDUz44NihI67ExL9xq5sorLZM0mrlwAdeSEu0LfNUqbdZX+S/xltrm27Spfv/EiVrSy/JLVwwapPUA1gfWoLtyeGqBn6vlYjlPrXmqyhgOFahcd44ePYpPPS1E2iB4emrfCgYDc+dtp3/cCsZ9O47xy8czrf80hncsCwAoH4w8rMMwbAw27D27t8pTezl50cGrAxvv34jhRa33cO7GuXx2/WcNdjvlsXrtmynWoruDg2WulMbmvfe09/XrLYdObGzgxRcv/ry2ttCtG3z6qbZ9551l+6xFe2ujTZuGXYDUGnRXDk8tMOdfMbMoepH++abwm/gh7gd9+6WhLzWaXYpGxtsbUlPJzEsD4Lcjv/Hbkd/4d+q/hHhpS2Sbe2kAbG20BCJVBSHPvWouXs5eFcqXxixtNIdH0bKxt6+4GGVd2bVLC4atLeUnKE6fXva5vmdJ7d2rLaMHTS8XkaJhUJmWS6kuU+O64+sY+nnlqwCKWUL/ZZ7/XL6K37kIMjMzq82OaTX8/juMHs3Ua+DdCyYbiFnav5HHPA+yCrP4656/uCrkKgBMwoTtHM35WTBiAe9Fv8exqccqvYT/fH+Sc5K5PeJ2vr7pa2KSYigoLqB/UMPMbmgy2jczrEX3F16Azz+HEycu/hzXXqvNCDPH2tQGe3stndlll138dS8Wa9G+pdGQuqtMy/VImG9YtfsPTj7Imn/XKGfnIjl79mzTeAC11XpqFq6q6PCYEwaap5v3a9NP32djsOGFK1/gZOZJpg+YzvQB06mK5JxkAL7Z/w1bTm3hRIb2TWR2qOqbJqN9M8NadLe312binD9/8ec4dw7uugs+ayKdktaifUvDGnRXDk8tCHAL0L9wzueex/cNXwB9Ackuvl3o4qvWI7pYUlNTZZtQO0rndtoKeH01PFUuw+2yfcuYEDkBAE8nT9wcLAP0Xhxau4CE5wc9z8sbtAVnzc5OQ9JktG9mWIvubm7atG1f30s7T1NK2mct2rc0rEF35fDUER8XH7JmZvF+9Ps82PtB2eY0C+yaygB7uV8nT26Grp/9ynVfXwdAQbGWMMTLyYtnrnim0sNrw0tXvcRj/R/Df75ldrCTGScbJCFhk9G+mWEtuk+cCB06lMW6XAwGQ9NyeKxF+5aGNeiuYnhKqe0YoKKFEx5elqc+P5/5O9/lyTVP8sbwN3hi4BO4z3NnzpA5/GfAfy7pMvf9dB9LY5ZalC2/bTlD2g/B08nzks6tUCgUzYnafn/bNKJNCkWlbN++XbYJtScurixYobCQR/o+AsCc9XNIyUkhuzCbItMlTnsBPhn7CVse2MJ3N3+nl93w7Q14vVZxVtel0KS0b0Yo3eWhtJeDNeiuHB6FdJpcJ6P5F0RREa4OroC2NpY5g3Kge+AlX8LGYMNlQZdxS7db6Nqqq8U+c2BzfdDktG8mKN3lobSXgzXorhwehXRatWol24S6YatNMWfuXIviT3ZrSznX98Kxrw17zWJ7ym9T+OdE/aTHbXLaNxOU7vJQ2svBGnRXDo9COl5e9TtM0+CYF6RZsACE4OMxH1vsNq+3Vl9c1/k6i+3/Hfgfg5cOrpdzNzntmwlKd3ko7eVgDborh0chncOHD8s2oW5s2FD2+a678HOp4pdLSoq2DHQDcTrz9CWfo8lp30xQustDaS8Ha9BdOTwKRV15++2yz19/Td/4fH1z4ciFWiY3gwH8/LTV9+ph7Pq6ztdxb897Lcq+3v/1JZ9XoVAoWgpqWnopalq6PNLT0/H09JRtRt147DFYVLqmWmQk7N5dtu/JJ2H+/LLt116DadO0lRovkc7vduZI6hF9+1IzMDdJ7ZsBSnd5KO3l0JC6q2npiiaDNWTgrDPvvgs//qh9jomxXIHx/fct6z79NPz3vxXP8eqrWk+QwQA7d8Lq1TVedvG1iy22TULLGFdUUkSxqbgudwA0Ue2bAUp3eSjt5WANuiuHRyGdlJQU2SZcHDfcADal/0Lff19Wnptbse7EiRXLZs4s+9y3L4wcWeMlL297ucX27jO72ZG4A4eXHbB/yb42VlvQZLVv4ijd5aG0l4M16K4cHoV0bGyacDN0LF0w1slJey8sLNu3Z0/Z5wu7WYuqSE5Ywwizk52TxTDW6K9GE/VRlL5d116eJq19E0bpLg+lvRysQXf5FihaPFFRUTVXslZ+/ll7//df7f3bb7X3KVOgRw/4/XdtOzRUe1+9WgtqPl3FDKv09Dpd/sIkhGvj19bp+CatfRNG6S4Ppb0crEF35fAopLNjxw7ZJlw8AwZo77Nna8tO33OPtv3889r7qFEwaxYkJmpxOiNHgrMzhIRo+4OCLM+XkHBJ5oz4ckTNlcrRpLVvwijd5aG0l4M16N6gDs8rr7zCwIEDcXFxqTI6++TJk4wZMwZXV1d8fX2ZOnUqheWHBYB9+/YxePBgnJ2dadOmDXPmzKmQpnr9+vX06dMHJycnOnTowJIlSxrqthT1TElJiWwTLh5XbWkJsrO14GQzfn5ln7284Px5LU7nQi4MZq6lw5PzbI7F9riwcfrnugxrNWntmzBKd3ko7eVgDbo3qMNTWFjILbfcwiOPPFLp/pKSEq699lpycnLYuHEj33zzDT/88AMzZszQ62RmZjJ8+HACAwOJjo7m3XffZf78+bz55pt6nfj4eEaPHs2gQYPYvXs3zz77LFOnTuWHH35oyNtT1BM+Pj6yTagfli7V3oXQZl6ZsbOzjO0pT5cultvmIbAacLF34c0R2v+Al5MXy29bru87mnq0thY3H+2bGEp3eSjt5WAVuotG4LPPPhNGo7FC+W+//SZsbGzE6dOn9bKvv/5aODo6ioyMDCGEEO+//74wGo0iPz9frzNv3jwRGBgoTCaTEEKIp556SoSFhVmce9KkSeKyyy6rtY0ZGRkC0K+raDyavOaffCKE5uZorwuJjLTcX/6Vny9Er16WZbGxQhw/XuNlswqyBLMR/m/4CyGEWBK9RDAb4T7XvdamN3ntmyhKd3ko7eXQkLrX9vtbagzPli1biIiIIDCwbHXpkSNHUlBQwM6dO/U6gwcPxtE8G6a0TmJiIsePH9frjBhhGbswcuRIduzYQVEVs2EKCgrIzMy0eCnkEBcXJ9uES6OmRfF+/bXsc5s22ntxsebeODrCrl2Ws7O6dYP27SEpSUtYOGFCpad1sXcBwMFWS2j4YO8HAZg1eFatTW/y2jdRlO7yUNrLwRp0t5N58aSkJPz9/S3KvLy8cHBwICkpSa/Tvn17izrmY5KSkggJCan0PP7+/hQXF3Pu3Dlat25d4drz5s3jxRdfrFC+Y8cOXF1d6d27N3FxceTl5eHu7k5ISAh79+4FoF27dphMJk6dOgVAZGQkR48eJTs7G1dXVzp37szu0sy7QUFB2NracuLECQB69OjB8ePHyczMxMnJiW7duunOXWBgIE5OTvxbOuMnIiKChIQE0tPTcXBwIDIyku3btwMQEBCAm5sbR49qwxfh4eGcPXuW1NRU7Ozs6NOnD9u3b0cIQatWrfDy8tLXMunSpQupqamkpKRgY2NDVFQUO3bsoKSkBB8fH/z8/PTGGRoaSmZmJmfPngWgf//+7Nq1i6KiIry8vAgMDCQ2NhaAjh07kpuby5kzZwDo27cv+/fvJz8/H6PRSNu2bdm3bx8A7du3p7i4mISEBNLS0igqKuLgwYPk5ubi5uZGx44d2VM6rbtt27aAFu8F0LNnT44dO0Z2djYuLi6EhYWxa9cuXW87OzvdGe7evTsnT54kIyMDJycnIiIi9OC51q1b4+LiwrFjxwDo1q0biYmJpKWlYW9vT+/evdm2bZvenjw8PDhy5Iiud3JyMufPn8fJ3p6epe3n+IwZmP79F29vbw4dOgRA586dMS+bF/P++0Ta27MzJobi4mK8vb3x9/cnLi6O/hc2xnLtdtsjj+Dp6UlQUBD79+8HoEOHDng6enJ/u/vZtm0bffr0AWDOujmM9hpN+/btLdpsSUkJCaUxQr169eLw4cOkpaURGxtLp06diImJASA4OBgbGxuLNhsfH09WVhbOzs6Eh4frerdp0wYHBwfi4+N1vU+dOkV6ejqOjo706NGD6Ohovc26urrqenft2pWkpCRSU1Mr6O3n54fRaNT1DgsL49y5c5w7d05vs9HR0ZhMJnx9ffH19eXgwYN6m83IyCA5OblCm/X29iYgIIADBw7obTYnJ0d/3kRFRbF3714KCgrw9PQkODhYb7MhISEUFhZyunSG3aU8I0wmk36v6hlR8zPCrHd9PCPy8vI4e/Zsoz4jbG1t6du3r95mW7VqVeEZkZaWRkpKCgaDgX79+rFz584KzwiATp06kZ2drbfZfv36ERMTQ2FhYaXPiPz8fBITEwHo06cPsbGx5Ofn4+HhUatnRE5ODm5ubpf8jEhLS2Pbtm0N8ozIybGMaaySunYdzZo1SwDVvqKjoy2OqWpIa+LEiWLEiBEVyu3t7cXXX38thBBi+PDh4qGHHrLYn5CQIACxZcsWIYQQoaGhYu7cuRZ1Nm7cKABx5syZSu8jPz9fZGRk6K9Tp06pIS1JnD9/XrYJ1sGPP1Y99FU6fFsTzEYwu/b/1kp7OSjd5aG0l0ND6l7bIa069/BMmTKF22+/vdo6F/bIVEVAQIDurZkx/9o399gEBATonqwZ8y+3murY2dlVGSjl6OhoMUymkEdmZibe3t6yzZDPDTeUuTgXJumaOxeee67eL6m0l4PSXR5KezlYg+51juHx9fUlLCys2peTOetsDQwYMID9+/fr3ZsAq1evxtHRUe+eHzBgAP/884/FVPXVq1cTGBioO1YDBgxgzZo1FudevXo1ffv2xd6+7un2FY2LuStcUYp5ba3yPP+8Vv7uu9Ue2tpNGwbrsqhLtfXMKO3loHSXh9JeDtage4MGLZ88eZKYmBhOnjxJSUkJMTExxMTEkJ2dDcCIESPo2rUr48ePZ/fu3fz111888cQTTJw4UV/x9M4778TR0ZEJEyawf/9+li9fzty5c5k+fTqG0qm/Dz/8MCdOnGD69OnExcXx6aef8sknn/DEE0805O0pFA1H795lvT3lmTq12sNW3L4CgMPnD1NYUsVUeIVCoWiJNNigmhDi3nvvrTTGZ+3atXqdEydOiGuvvVY4OzsLb29vMWXKFIsp6EIIsXfvXjFo0CDh6OgoAgICxOzZs/Up6WbWrVsnevXqJRwcHET79u3F4sWL62SrmpausFqmTbOM5/n112qrm+N49iTtEQeSD4jn/3q+kQxVKBSKxqe2398GIWpYrbCFkJmZidFoJCMjQ+9dUjQOu3btonfv3rLNsF7OnoWAgLLtKVOqHdr6X+z/uPX7WwHo6NWRY2nHyH8uH0e7ijFru3btIt0rnU93f4qviy9vjXqrvq1XVIJq8/JQ2suhIXWv7fe3WktLIZ2qciUpSrkg5QKLFlVb/cbwG/XPx9K06Z1r/l1Tad2ioiKu/u/VLNu3jLe3vU1OYS2ndyouCdXm5aG0l4M16K4cHoV0vLy8aq6kqDW2Nrb835X/Z1E25usxlda9UPuVR1ZaVnjoIS1Y2grWwWlOqDYvD6W9HKxBd+XwKKRTPtO2ogr++QfKp3C4+27o16/K6ik5KbU67YXaf73/a/3zsr3LGJH/kbZxQdoHxaWh2rw8lPZysAbdlcOjkI45C6uiGgYN0hyc++/Xtpctg+joskVJe/TQemJKs6R6OVf8NfXsX8+yPG453+z/hhJTCX8c/QP3Be4WdVYcXMGTq59ECMHdy+9mTUd47Bqga9eGvLsWh2rz8lDay8EadFcOj0LRlJg503J7zRp47DEoTcdPcDAAd0TcUeHQeRvnceN3N3LHD3fw+Z7PGbVslMV+39Lwnflb5vPHsT/08kX9gczMirmBFAqFogmhHB6FdDp27CjbhKZDp06W29ddV2kQc3f/7hT9XxEdvDpUeprKhrz8y8UrX7PsmooHzZ8PP/xQJ3MVlaPavDyU9nKwBt2Vw6OQTm5urmwTmhYmU/X7SxestLOx49jUY9wXeV+FKkdSj1hsR52GZNcarvvNN3DzzRWTISrqjGrz8lDay8EadFcOj0I65ZcWUdQCgwGuvbZi+fDh2vtNN1kUvzf6PSb1mWRR9snuTyy2u5+FlJocHjN3312z06WoFtXm5aG0l4M16K4cHoWiKfLrr5bbcXHwdekMqyuusNjlbO9MQmZCpad563ftPcMJbjruUuXlLPp0vvqqQRYyVSgUioZEOTwK6fTt21e2CU2Tw4e191atICwMfHy07ePHK1S9KuSqSk8xZTts/AS+/h46mIwA/Pk5pLwOa5eW1Ut8+2XLA1999RKNb9moNi8Ppb0crEF35fAopLN//37ZJjRNSmdkYW9vWb58eYWqj/V7rNJT2Aq4/BTY/2cGz353hic3weAT4JsLQ46D0VFzgt7vlqvF7kRGagfec0893UTLRLV5eSjt5WANuiuHRyGd/Px82SY0TRxL18by86uxqr1tmVPUv3R0K+IsnB82TNtYswZPv7a8vgbsyoXnnJh2AoC5G+dqw2K//KLt6Nz5ks1vyag2Lw+lvRysQXfl8CikYzQaZZvQNDEY4NNP4eefLcsA3nmnQvWfOs8iZjEsK51Z3j0ZUmfP1qa6//ADXH+9tmPJElixAoTA6FT2t3lx3YsYPgnGMBuyVv/SILfUUlBtXh5KezlYg+5qtfRS1Grp8sjNzcXFpeqAWUUdmDcPnn1W+1xcDLa2ZfvefhumTQPgvz1hzCFwPJ9Tpv2mTVrAc1KSxYKlhhcNFS5z0wH4/pMscHNrqDtp1qg2Lw+lvRwaUne1WrqiybDPnCVYcek880zZ59RU7bVqlbZd6uwA3LMHvPIv0P7yy7U4nQtWZ/d18a1wmZWhgLs7WMEKyE0R1eblobSXgzXorhwehaI5YTBojgtosT333QfXXKP19pj55hvtfejQWp1y78N7K5T9Z2vph06dVCJChULRJFAOj0I67du3l21C8+KPsnWw9Pie8utg3XQThIbCiy/WSvvW7q25P1JbtPTJgU8CYF8C7/aDklMnYdeu+rK8xaDavDyU9nKwBt2Vw6OQTnH53gfFpePqajm0BTCqdKHQZ58FOzsth8+gQbXW/pPrP0HMErw+/HUA5gyBqaMh6iEwFRbUo/EtA9Xm5aG0l4M16K4cHoV0EhIqzwKsuATy8iy309O1d1/LeJxL1X53a9h18+VqWKuOqDYvD6W9HKxBd+XwKBTNEQeHyssPHbrkU/u7WgY125mAo0cv+bwKhULRkCiHRyGd3r17yzah+TFoUOXl5lw7pVyM9hvv32ixnWeHlojwu+9g2bI6n68lotq8PJT2crAG3ZXDo5DOwYMHZZvQ/BgzBsxdyNOmabE7ycnajK1yXIz2bY1tLbZz7YHRo+G227SV1BU1otq8PJT2crAG3e1kG6BQ5ObmyjahedKmDeTkgLNzWQbmC7gY7R1sHTj/1HmyCrJo/3Z7Po+Eq5f/donGtixUm5eH0l4O1qC76uFRSMdNZettOFxcqnR24OK193b2xsdFW539i55QrJ4kdUK1eXko7eVgDbqrx5RCOh07dpRtQovlUrR3cyh7gK0Ig8M+EOeLloFZUS2qzctDaS8Ha9BdOTwK6ezZs0e2CS2WS9X+1H9OAbCmA3R5DLpOAbKz68Gy5o1q8/JQ2svBGnRXDo9CobhogjyCAPiwr2RDFAqFogaUw6OQTtu2bWuupGgQGkR7e3uViLAGVJuXh9JeDtagu3J4FApF/VJUBMeOybZCoVAoLFAOj0I6J0+elG1Ci6U+tP/qxq8qFi5YcMnnbc6oNi8Ppb0crEF35fAoFIpL4o7ud1hs59kBS5bIMUahUCiqQDk8Cun07NlTtgktlobQ/pQR8POr9/M2J1Sbl4fSXg7WoLtyeBTSOabiPaTRENp3eQywgnVzrBnV5uWhtJeDNeiuHB6FdLJV3hZpNJj2OTnae1KSlum5U6eGuU4TRbV5eSjt5WANuiuHRyEdFxcX2Sa0WOpLewdbB24Kv6msYMMGyMuDWbO07WPH4Kqraj5Rhw6ag2QFD8eGRLV5eSjt5WANuiuHRyGdsLAw2Sa0WOpL+4LnC/j+1u9Zcu0SbE1QYgDWr4fjx8sqrV2rOTNVre2Vmgrx8drngwe1XiKjEbZtu3jD2rSBH364+OMbCNXm5aG0l4M16K4cHoV0du3aJduEFkt9a+/q4EqJDfwUBlxzDXTtysLLYPmFzzqDAd55x7Jsw4ayz0VF8NBDkJkJl112ccaUlEBiIvzf/13c8Q2IavPyUNrLwRp0bzCH5/jx4zzwwAOEhITg7OxMx44dmTVrFoWFhRb1Tp48yZgxY3B1dcXX15epU6dWqLNv3z4GDx6Ms7Mzbdq0Yc6cOYgLMrmuX7+ePn364OTkRIcOHViipsUqFI3O4HaDAfikF3DNNWS9/xbTR8GNt8PvF4bxPP447N5d5uh8/z259vBxbxADB8JX5fL7lJTUfPGVKzVHytyrlJmpvcfFQX7+pdyWQqFoBtg11IkPHjyIyWTigw8+oFOnTuzfv5+JEyeSk5PD/PnzASgpKeHaa6+lVatWbNy4kfPnz3PvvfcihODdd98FIDMzk+HDhzN06FCio6M5fPgwEyZMwNXVlRkzZgAQHx/P6NGjmThxIl9++SWbNm3i0UcfpVWrVtx0001V2qiwDoKCgmSb0GKpb+2DjcEA/NYZ+KdAm6Jeyui7tff3f4VHdpQWmmdzmUzkfvslrs9pm/1OQ4+z5U6ckQE+PtrnDz+Ea6+FwMCy/cePw3XXaZ/HjIGYGPD2Ltvv7AwmE3z8MYwdC/7+l36zl4Bq8/JQ2svBKnQXjcjrr78uQkJC9O3ffvtN2NjYiNOnT+tlX3/9tXB0dBQZGRlCCCHef/99YTQaRX5+vl5n3rx5IjAwUJhMJiGEEE899ZQICwuzuNakSZPEZZddVmvbMjIyBKBfV9F4JCUlyTahxdIQ2nd+t7MY9FygECBWdUQwu/LXEW+EoOx10Kds37Y2lvuEo6Pl9siRQhQVCREebllufn3xRcWy+Piyz5JRbV4eSns5NKTutf3+btQYnoyMDLzL/erasmULERERBJb7pTZy5EgKCgrYuXOnXmfw4ME4Ojpa1ElMTOR4adf1li1bGDFihMW1Ro4cyY4dOygqKqrUloKCAjIzMy1eCjkcLx/YqmhUGkL7nv49cbR3ArQkhAYqD1K+8j4tK3OOvbb9aa+yff0nQpYDnL/vNgRAQYHlwfHxsGqVNlxVGePHVyzr37/sc0ZG7W6mgVBtXh5KezlYg+4NNqR1IceOHePdd99lQbk1dpKSkvC/oGvZy8sLBwcHkpKS9Drt27e3qGM+JikpiZCQkErP4+/vT3FxMefOnaN169YV7Jk3bx4vvvhihfIdO3bg6upK7969iYuLIy8vD3d3d0JCQti7dy8A7dq1w2QycerUKQAiIyM5evQo2dnZuLq60rlzZ3bv3g1o3Xi2tracOHECgB49enD8+HEyMzNxcnKiW7duunMXGBiIk5MT//77LwAREREkJCSQnp6Og4MDkZGRbN++HYCAgADc3Nw4evQoAOHh4Zw9e5bU1FTs7Ozo06cP27dvRwhBq1at8PLy4vDhwwB06dKF1NRUUlJSsLGxISoqih07dlBSUoKPjw9+fn7ElX6RhIaGkpmZydmz2vhC//792bVrF0VFRXh5eREYGEhsbCwAHTt2JDc3lzNnzgDQt29f9u/fT35+PkajkbZt27Jv3z4A2rdvT3FxMQkJCaSlpVFUVMTBgwfJzc3Fzc2Njh07smfPHqBslV3zWiw9e/bk2LFjZGdn4+LiQlhYmB4QFxQUhJ2dnf7P1b17d06ePElGRgZOTk5ERESwY4c2ntK6dWtcXFz0hFjdunUjMTGRtLQ07O3t6d27N9tKZwj5+/vj4eHBkSNHdL2Tk5M5f/48tra29O3bl+joaEwmE61atcLb25tDhw4B0LlzZ9LS0khJScFgMNCvXz927txJcXEx3t7e+Pv763p36tSJ7Oxsvf3369ePmJgYCgsL8fT0JCgoiP379wPQoUMH8vPzSUxMBKBPnz7ExsaSn5+Ph4cH7du3t2izJSUlJCQkANCrVy8OHz5MWloasbGxdOrUiZiYGACCg4OxsbGxaLPx8fFkZWXh7OxMeHi4rnebNm1wcHAgvnR2Vffu3cnNzuUfoR170gi+jj7878rvGbJmiMX/2hl3iHwYDvuCmA2vX2Gxm8AZkO34LZ/0gvt3W+7j8GFt6KocMQGwMhSeKxf7PHsI3L4fws4Bycl6+b5ffiE3NJSOHTuSk5Oj6x0VFcXevXspKCjA09OT4OBgvc2GhIRQWFjI6dOnAS7pGWEymfS2pZ4RNT8jzHrXxzMiLy+Ps2fPqmdELZ8ROTk5uLm5XfIzIi0tjW3bttG9e3dOnTpFeno6jo6O9OjRg+joaL3Nurq66np37dqVpKQkUlNTK+jt5+eH0WjkyJEj5JjzftWAQYgLon9rYPbs2ZU6CuWJjo6mb9+++nZiYiKDBw9m8ODBfPzxx3r5Qw89xIkTJ/jjjz8sjndwcOC///0vt99+OyNGjCAkJIQPPvhA33/69GmCgoLYsmULl112GZ07d+a+++5j5syZep1NmzZxxRVXcObMGQICAirYWFBQQEG5X42ZmZkEBweTkZGBh4dH7QVRXDK5ublWkaOhJdIQ2hte1Hp0zsyH1k9oZWKW9pjZe3YvPZdUTDH/4lqYNbTqc4rZNV83+FU/EvKT9bomA9jOgm6turF/cqxl5UmTpK73pdq8PJT2cmhI3TMzMzEajTV+f9d5SGvKlCnExcVV+4qIiNDrJyYmMnToUAYMGMCHH35oca6AgADdSzVj/rVv7rGprE5y6S+1murY2dnhYw50vABHR0c8PDwsXgo5WMMqui2VhtT+PyMrlvXw74GYJXgw0LJ3pryz8/tdv1c4rsAWDvnA2pceqPJ6CfnacyHtumFA6SKmQGxKLOLuuywrl/sBJQPV5uWhtJeDNeheZ4fH19eXsLCwal9OTtr4/enTpxkyZAi9e/fms88+w8bG8nIDBgxg//79evcmwOrVq3F0dKRPnz56nX/++cdiqvrq1asJDAzUh7oGDBjAmjVrLM69evVq+vbti729fV1vUdHIZEiOp2jJNIT2q+5aBcA33auu83HiL5WWt3Fvw6hOoyqUpztB2GNwVcknGGbDhralOwYOhPx8Vh74Sa876R4vTHfcjttzZcfbdFoGQHQg5F/WF+6+u073VN+oNi8Ppb0crEH3BgtaTkxMZMiQIQQHBzN//nxSUlJISkqy6IkZMWIEXbt2Zfz48ezevZu//vqLJ554gokTJ+o9LnfeeSeOjo5MmDCB/fv3s3z5cubOncv06dMxlGZsffjhhzlx4gTTp08nLi6OTz/9lE8++YQnnniioW5PUY+YHWRF49MQ2o/sNJKRHcu6d36949dq67s7uOuf/+9KLUlgD/8eAPg4az20AU9aHjNjJKQ6g2HEZgyvOnHdd9fr+/534H/snl/xf/+cC/R7CJxH7YAvv6zbTdUzqs3Lo1lof/SoFsfWhLAG3RvM4Vm9ejVHjx7l77//JigoiNatW+svM7a2tqxcuRInJycuv/xybr31VsaNG6fn6QEwGo2sWbOGhIQE+vbty6OPPsr06dOZPn26XickJITffvuNdevWERkZyUsvvcQ777yjcvA0EcoPgSoal4bS3t+tbBJBN79uFfbfEHYDABvv28jp6af18i6+XQDYdP8mABaMWFDhWIDoNvBRNQuy9/2ob4WyR64t+5xnh5aXRxKqzcujWWgfGgpdusi2ok5Yg+51DlpurtQ26ElR/2zbto3+5acMKxqNhtL+idVPsGCL5qyYA5YvFnMQdH0StwjCPl4B119fY92GQLV5eTRZ7YuKtOzj3bpBVJRWZjJVvTadldGQujdY0LJCoVDUhK+Lb72d66qQWqyyDpx/6jxdfCx/9f5+1++YXqjYk7MyFBg3rh6sUygaifvugwkTypwdKFs+RVErlMOjkE5leZIUjUNDaW+OvakP/jvuv/rnrQ9spbNP5wp1+rfpj7ezN0vHLbUov7LdlRgMBm7tdqtF+RPmEKPFi7VlKU6cgM8+qzeba0K1eXk0We2XLatYlpbW+HZcJNagu3J4FNJROTHk0VDau9hr572r+1011KyZALcAxnYZS+yjsfQP6s+cIXP0fbMGz0LMEmx9cCsAlwVdhpglCPMNs7AjyL1sHR+jo5FbzGl5Hn0UQkKgfXu4//5Gi+tRbV4eVqd9djaUJgqsNa1aae9NyOGxBt2Vw6OQjjmrpqLxaSjtbW1sAfB29q6hZu3O9dPtP9G1VVcAi96ae3veW+kxWx/YSsJ/EvRto5O2iqmPsw/hrcI50qUVmY6VHLj7wpTODYNq8/KwKu3//hvc3aF7d5gzp+b6Zt58U3tvQg6PNeiuHB6FQlHv3B5xO5vu38TCkQvr/dwGg4HRoaOJCowixCuk0jpGJyNtPNro2+aYomeueIatCVuJsUvBOLOSA/Pz691ehaJSMjPh6qsBWDAANn08q+q6KSnae1SU1is5TEuuSelyHoraoWZplaJmackjOzsbNzc32Wa0SFqK9kII4s7FEe4bjs2cst95h7b1o8Mf27Ezj2StXAmjRze4PS1Fd2vEarQvN7vKMFt7F71+grFjK9Z95hl47TW46y4th1RJCdiVphJvIl/hDam7mqWlaDKYF7ZTND4tRXuDwUDXVl0xGAzY2ZStmdyl/3beWDe3rGfn3DntPSVFC2RuIFqK7taIFO0LCzVHpdz6jZWxaUoVaRK8S4eGzTMLbW3L9jWRBITW0OaVw6OQTloTGodubrRE7TOfsZzKezj1MDiWBvTce68WQOrnpwUyly5fU9+0RN2tBSnaT54M48fD1KnadunK5xdyxQOUDV+ZycmBp5/m5SvhKeP2igc1kQSE1tDmlcOjkI5a70weLVF7Z3tn4iaXfeG42F0we6R7uUXATpxokJlbLVF3ne3boU0byMuDtWu1WUqNSKNrLwR8/LH2eXupw1JuNQEuuwx7mzKbzv+90vL4PXsA+L+r4I3Nb5SVV5ZHKiUFZlYWnCYfa2jzyuFRSKd372rWCFA0KC1V+/IJCrv7V7PKKcB779X79Vuq7gBMmwaJibB6NVx1lRaE24g0uvblFr7m5ElYvx4+/VTbFgK2bMHGYEM792AAdr39jLbPZIJvv4WEBC5kf/J+9i55UdsYPrxsh58fvPqq9MVxK8Ma2rxyeBTS2bZtm2wTWiwtVXuDwaAvefFv2r8kZSfxU9wKuPnmipUbYKHRlqo7AF5e2vsmbb00vviiUS/f6Nr/8EPZ54gIGDLEYvfCLQspKCng8vaDAHivXenMq6++gttvh9tuq3DK7ou703NJTxg5EtasgQUL4ODBsgrLllndkhPW0OaVw6NQKFo0b2x+g9YLWjPu23GI774r23GDtsCpHt+jqB9++017f6Pc8ExurhxbGpr0dG1mlZl//qlQZfpqbSHs5JxkAH4KK90xfrxe53C5xOX/nCg7h/jjD+3DE09AeHi9mHxJZGTAokVWO3NMOTwK6fj7+9dcSdEgKO0tiU2JhXvu0TaWLYPISG1l6hpm19SVFqf7+vXaEFZVNOCMuAtpVO3Lx+pcyPjxlM8K88sdv1RZ9bfQss+Dlw7WP2fcW7H3xwIhIDVVm8bekERHQ9u24OkJjz0GNhVdC2to88rhUUhH5T2Sh9LekvT8dPjgA20WjbMzxMRo8RZOTrBxY71dp8XpPmSINvzyzDOV7//660YzpVG1N+ed2bcPrrnGct/nn9P3o74AuDu442TnxC2JXvRJBI4eJd8Onr8K8u0gqYr0NWkL51UsvPZaeOUV8PGBXr2094ZeHb5fPzh1qvJ9W7aAwYCnmqWlUMCRI0dkm9Biaenar77bstchqyBLc27CwipW3rmz3q7b7HXPz9eCky9czfu117T3jh0ty81xPY1Ao2qfkKDN+ouIgO+/LytfvZqVR35j15ldADzW7zEA/heYxs5ASOoVyie94JUrwfl5eO0Ky9NGBkQCkJZ/gRNhZ6cF2bduDefP6zO86rPtVmDz5oplRmNZsPbAgQB4qqBlhUKhkMfwjsMRswS5z2oxJOdytcSDmQWZ+mcdK1j8sMmwZg28/XaZg3MhFy6WOX16w9skg+3bwceHYlMxG8/totgGLZh4+HCu+/o6vdrAYM0pGNlqAACtn4Ap11Z92icHPglAWl4a/Pxz2Y4zZ6BdO+39QvbuveTbscBk0u7l8ssty/v312J5HnigynxDslAOj0I64dYQbNdCUdprONs7A3DPins4nn4c46tGWr3Rihu/LPtSqs91tpqk7nl5UNsFIM1fwnPnVr7fyUnLGXP+fFlZPQ4ZVkeDa79rl+YIHD+uxbasW8dTa55i0GeDmPn7E2AyYRKWuZ2u7ax5N6+Me1cv88yzPO2+R/Zx7slzzLxiJsM7aFPRE7MSYcyYsoSGvtqacYwZU9Gunj3r5fZ0zAuYmpk+XUuSeP/92vaXX1rMeiy6voos0o2IcngU0klOTpZtQotFaV+RkLfLFiRdfvTXsh1JSfV2jSap+7Bh8P/tnXdYFNf6x79Lry4gAgIWsKGiomCL5CoxatRYYqrdmFiSEDUmmkRjN+pNvEl+XjUmJjGmqDdeNdFcjaCxoShKEbFhoVjoICC9nN8fZ2dmZxuL7O4scD7P47OzZ87OnP0yzrx7zls6dtRPBy7RniY4R113d1oy4ZVX6Ptnnmn4GPXA6NoHB9NXP3odVVoCX56nRXRPpp0EAHwXp1mfYO9gfvuRvXhf91bd0dKhJdYNXQc3e1pqYtrvCgf7L7+kBimHl1cDv0QdJCYCixaJ2154gc6ChirW31xcgJs3+d1puhy4TQQzeBiSk6f8K49hUpj2dVOWqPB/0LRM8IQ0St05X43WrXX3y88Xv1euofTVV+r9uVQAVVVPPLT60GDtCaHJ/XJz6+4LYO7ibvw2t0z6r+h/8W1nXj+j13FkSnl1LC2EWlqJWYk0KsrOTuis7JjNpVcAGpY1/MAB4Px5uq06WxQdLRg63boBs2bRkHwuOqxrV7O45pnBw5AcS+VCeAyTwrQXICsI+nr3VWt/4NOCPjQMWPyw0euenU0jrpTzrVy/TgtZtmwp7vs/RamEoCDgrbfUj5WQQF+dnY0xUjUarP2aNbR8g5+f5v0eHvxmjA+ww/Ya/76TG40vT86jBT/JCoLQtmKP5MOTDtdrOL22aViqUs4dtW+fUG5C1RitDxMmAAMHAlevqu/r10/8XjUPz+nTZnHNM4OHITkhISFSD6HZwrQXEzNLKM7YTt4OAHA2/SxQXAwcPWqwytSNRveff6b+KMeOids9PalD8v79Qlu3bpoLWc6fT1/PnAFsbNT39+pFI7pMlHywwdqvWEFfNdUAW7qUGoMKflcJ9uvTug9KKkt0Ht7dwZ3fbuXQil++UuWN3m/oN16ZDBg1SnHAVkDnzvp9ThuBgcJ2dDT1vVLNu9OunbA9aBDg7m4W1zwzeBiSc/HiRamH0Gxh2qszoesEAMCFN2kq/Bl/zBCiTf76yyDnaDS6c0kYP/lEaPP3F7Y1leLgeP99+jqQRh7xOWk00bs3Xf6oqKCO0UeOPNl49aBB2m/aJH7v4UGXejg4J+3Zs4GnnoJVr96i7mfvnYXTeh06QOGIrODgxINInJuImDfVq6R/N5b6AY3sOFJtHwBaY4tzLFb26bl1S3v0nDaysjS39+mjHqUFAIsXC9uK7NLmcM0zg4chObVGqEbN0A+mvTo7x+9E9BvR8HSimWEnBk4UHuzz5xvEeblR6K48g6FcB+nuXXE/QsQOswANSR+syAj89991n8tNMYtx5gx1jB41ijo1G6FEwRNrT4iQOLGTIvVxTg5d6lHl7l3g7Fnc/0cQ+vv05+u2RaULkWjaMiu3sBX8b+yt7OHTwgd9fdSXWgFgRIcROHL7CFacoLNO4/aMg2yVDMfvHqeZrd97j3ZU9bvSlgBSG6p/cw4NM3aEENoeE0OzlStmf8zhmmcGD0NyWrVqJfUQmi1Me3WcbJwwwHcAAKCnZ0/sTtqNteNcUWal6KBcDPIJaRS699XwkNW0LJGZKfjhcISHa/68NjiDR7nyd16exkrhDaXe2u/aRcO8w8IEw44LA+dQSb5XNpcuN+1I2IHCikKNh3267dMa28P8wvDzCz9jSPsh6NxS9/LT0Tu0ltbq06sBAAdv0nQAz/78LH6I/0Ho6Oio8zh1olr644sv1P4f1NTWoM83fWCx2oJmLO/bF5g0id9vDtc8M3gYkuPmpnmNmmF8mPa6ScyiydqWnV6JH7jVifDwBh+3UeiuXH2bQ9mXx8eHvi5axGfTBUB9XCwsxNmTV67UfS5tMzlctl4DUm/tJ08G/vyT1gMDaHh+27biPt98Q1/bt0ekP+CQNBGHbtIZnBu5GnQE4Gyr3Ul7Ss8pODH9BJ8fShsL+i8AAAz1GyqqywUAbxxU8fFZvJgmhPz6a/r30XfG5eJFYOJEcdt776nNbMk3yBGfGQ8AyCtVj8gyh2ueGTwMybmplKuBYVqY9vojU34zdGiDjmVw3R8/pmHAVVUip1mDI5cL25wD959KuYqiogTjRjlSSDVniyrayg4YMNkjR4O1f/FFYOxY8Xf66Sf6KpfjxEv0u4zdM1b0sfg58aL3FrKGP36/fO5LDGozCD4tfLAnaY/uzv/8JzXW3NyosVNcrN9JVJ2zNcwWlVaVoqRKcMa+X6Q+M2cO9xpm8DAYDIYWdozbwW9bz54r5DfRxy/FVBw4QEO6XV2BOXNoBFV9+PxzGsmjXFGb+/Xv70+Xcb79VjCkhg4F3nmHJpnz9aVlBDg0hScTUndZDnstMxlGMHjqRVyc+P1XXwFz59Ltzz4DlAtiVlcDly+jEuLK5Ilz6SxhL08hfJzz6TEEVhZWuJF7A+8eofW4PB098VK3l0TRXiI4fxxlQ1Vf3n8fOHtWrbnPN2KDdcjOIfU/tglgBg9Dcjo3NEyS8cQw7XUzvdd0fjsvoJ3BwtINqrvy0sIOhYFWXa29/3/+I3Yy5iJqLlygFa+vXwcOK3LB2NvThHazZtGQZoAua23eTLeVI69qawFr6yf/Hlz0l7I2RjB49NL+iy+oEXjihLhd1XfHxQVYtoxuK757edJlUZcenj0A0MSB9967h8z3DZexGwBOpZ1CzIMY5JXRZaQ1YWswwGcAKqorNH+AK/Hg4qLfCZRngjZu1Fii4mYenb3hfN80YQ73GmbwMCSnQPlXEsOkMO11I5PJMD5gPAAgoziDzp78S5EltwH+JUbXXVsW4Bs3gNdeozMzgHhWZ9Ag6pvSrZtQi4nLgqwN5WroMpn2fvrAjWn3biENgBEMHr2050LqP/hA3K7pO86YIXqbHRqk9bC+LXz56D9j8WafN+Fk44SSqhLkl+VjUcQi5JTkCB24xIj6Xr9r19LXvXtFzdW11ZCtkmHJ8SV8275X9uHjUJrksLBc7KxtDvcaZvAwJCcnJ6fuTgyjwLSvmwOvHkA/n37YFLOJOqByIckNyFr7xLpXVdHkdpyhEhGhud/Wrept1dWCw7WtLZ2l4XLkaENbNmEOA2af5peKAgMFXyFN30MThNCZlhLdSf0APbTXZCw+eqTdsVopL9FDZ+BwbTKm9ZqGszPP6l02wlCse2YdZDIZHG0cUUtq0fKzltgYvREeG4Xsz7wPji6tbt4E2rShYfdc/hyVnEvvHqZLaOuj1gMAfnvpN3g7e/OzPWN2U6M5pyQHz/3yHO5l3jPAN2wYzOBhSI6sob8MGU8M014/8suocdN1S1ehInXr1uJMw/XgiXW3saHJ7RYsoO9nzdLcb80a9XxB27cDx4/T7YwM4N13hYeZNrT51qiiKflcfZk4kRoVNjZCXSh99f3jDzoToSu5oYI6tY+OVm9TKnuRUZwB2SoZ1p5eq9atw3wZSqpL4ePsg6faPKVWNsLYcLNHTjY6dOCcyadO1eiPA4Auk96/LyqToczxu8exLXabqM3LiSY33H+d/s3OpFNjz2OjB47eOYolCUsgNczgYUhOP1VHR4bJYNrrRysHIYdIopfSA/MJnZfrrfvDh0ISOUCYhUhP1/6ZhQuF7exs4O2363dOfcjPB954Q730RENRjvDSh3rkeKlTe9WH/J49otIJ3l94AwCWnVgG2SoZZKtk/MxZuRWdBUp9lKr3eBpKcrjgVzal5xQA0FiOorpW4delbPCFajHIrl0Tv1epvv7sz8+qfYQzsq6+TWttBXoE8j8UAOBczjm1z5gaZvAwJCc2NlbqITRbmPb6YWclVKJ+78xSYUfPnpo/cOAA8OABLcmgIWqq3ro/95y40nhYmDiPCiFqye+we7ewXZ/ILa4cgXIIujZcXYHvvhNX6jYE9T1eTU3dfRTUqb2y47WlJfDqq/zbaznXNHwAqJggDkHv4NpB7/E0lE4tO+HXCb+in08/2FjSzMeaDJ7Pz36u+QD6ZLPeI4S819Rq1prLEN2tVTdM7TkVcls5puyfUvexTQgzeBiSU60rooRhVJj2+rFu6Dp++++Uv1F1VuGbMWeOeucWLeiSgK8v8OmndHZFJqOh3Qqqq6vpg2bzZnFoszauXBG/f/xYyG7MzdwMGCDUcuIYPx44pLmEAY9yJNLevXQm6fp1wXFYCiwsgO7d6bY+jsvKS3N1JLir85rnDEkbGyFaTUGPr3to/MhuB3Hphec7P6/7HAZmUo9JfO03QLPBE+QVJLy5p+RPc/kyNc47dNDuyDx4MAghqCW1sFpjxTdvHkmj9ZxtnNHBTTDyPB09kVWSxfvzAMD5587X81sZHmbwMCTHHDJwNleY9vqhGm5rE6m5LABKS7UndONCuaHQPTOT+tFo+huUl4tnLbj8Pxzvvy8YW9yrTAZ8/LHoPPjjD5ozRxllH5UVK4AhQ4TMwb0V6aQDAtTrLxmQLTFbcC3nGr6M/lJjkjoAwMsv01dvbyGTsTaUo6kKCsTRYyrUec1XVdHX2Fhg+HDRrlpCjaHPnv1M1P76X9Thus9DWhG9v29/3ecwMq52QpbrTc/RgqfKiQHh6wv8+990OzcXGDGC5uf56SfBwNym8NFR+HHN/2s+LFdbis4zqcckPN32aX4Zi8PN3g2382/jbgE1BN0d3M3iXsMMHobkeNY3URrDYDDt9Sfrgyz89+X/Cg2cX8POnULZAR0PWuQJ6fY9PT2pMcIfPEu8tGBvD0xRWg7gZjuUuXSJvqouq73zDs21w8H9mv/4Y+D33+lM0Ouv07bSUvHYuHIRRmRnwk6EHwlH963dsTBiIZ7fpWU2JCCAvhYU0Aiu+hQS1bEcp/Oav3FDKJPhrjlxn7uDOwg0jCUrC1WBXTGojQEcuBuIckkKzq9n7p9zxZ1mz6avX34JXFUYLNu3CzOO3t7Ud0xx/fw75t9q53G1d8Xp10+jjbyNqF3VMfzQxENmca9hBg9Dcq5LOXXezGHa64+HowfGBYzj35Nff6UbM2bQWZLPPtNt8ChFTV2/fl38QPXyAlatEvfn/CbS0uisTKdO2vPrqMLl0VFm3Toh6dzy5fSVi/biftUb2hdHA2tOrxG9v5x1WXPHLl3E72fOVO+zebP2/D8pKRqLj+q85pVLhigcoQvKCnA95zpfG2tQm0GYE0xn1fp69+X9u+JrHuBK/nWcuye9c64yLnYuAMAnJuThKp0rL9tdviwYPK6udJavZUuNx1UtlaHMtkviCK4BvgPM4l5jVINn7NixaNu2Lezs7NC6dWtMnToVD1XyNqSnp2PMmDFwdHSEu7s75s2bh0qVdcQrV65g8ODBsLe3h4+PD1avXq1WKO3UqVMIDg6GnZ0d/P39sW2bWHAGg8FoKFYWVtg1YRcAoESuErItk4kNnmPHhOURgPqGKBfRtBJ8IQBQgychQb2oI/dL3N1d68NHDXt73ctA7dvTGRNvGnGEc+eALVv0O3YDaStvq9ammqQOABAUJH7/4490pqe6GkhNpbNS774r7H/zTfqdpk6l7/39aS6ZPJUHvS6Un0+WdPnG7TM3dNvaja+NdTL1JOR2cjz68BFOv34a+16hVcP7fEvLK8RmmEcgwNejv8a5med0h+FPny520q6oEGYT63BaF/kEqXBw4kF+u2RJ3bmRTIVRDZ6wsDD89ttvuHnzJvbt24c7d+7gJaXkRTU1NRg9ejRKSkoQFRWFPXv2YN++fXify3IJoKioCMOGDYO3tzcuXryIf//739i4cSO+4CIJAKSkpGDUqFF4+umnER8fjyVLlmDevHnYp1K+nmGedOzYUeohNFuY9vWHq1G0/Mom1Cg/SxISgFu36Pbp03S2wMqKPkS5NP6rVgG1tVR3TYkLe/cW16bas0dILsjlTKmsBJKS6PbHH2sfKGcoAfTBr4t+/YwTtq6BE6kn1Nqu5lzV0BPADz+I33/zDTXm/PzUl5y4pIpKzuEA6BKeEnpd8zqMRW52R24nh52VHYb6iQvJKjsPS8nckLkY2EacWJIPTefw8BCMclXDSGkJ6mauuPDn5blaZuUU9PTsia2jtmJQm0FwsKZ11MziXkNMyB9//EFkMhmprKwkhBBy+PBhYmFhQR48eMD32b17N7G1tSWFhYWEEEK2bt1K5HI5KS8v5/usX7+eeHt7k9raWkIIIYsXLyYBAQGic82ZM4cMGDBA77EVFhYSAPx5GaYjNTVV6iE0W5j29edq9lWClSBYCTJzLAg5epQrkSn8y84WfygxUbQ/NTWVEDs79c8BhIwYobmdEBJzP4ZgJUhiZiIhlZWEKO6BWnn/ffrZmhojqaEfn0V9RpYeX0oIIbx2yv9Wn1yt/cNRUZr1UP136xbtX1Ojvi83lz+czmteSWtCCMkrzVMba2G5+jNCeX9NrbRaa2LPlT0EK0EKygrEOxYtEr4zd62oaEAIIWfTz4q+45NgzHuNvs9vk/nw5Ofn49dff8VTTz0Fa8UUWnR0NAIDA+HNTasCGDFiBCoqKvhcCdHR0Rg8eDBslRJRjRgxAg8fPkRqairfZ7iKN/2IESNw6dIlVClPKStRUVGBoqIi0T+GNGSqZoRlmAymff3p6t6V3+615P/UInkAqCfCCwwUvc25c0fwm1F1xj16VP14irYZf8wAQCNmYG1dd/2qjRvp8S2kdddcfGwxPj3zKRzX0bIGz/g9I9pfVCHcf7+P+x6yVTLBbWHQIPod6sr6zJVM0PRdlWZ5tF7zSs+AlIIUjN41GmfTxZmIy5aW8flmNNHBtQMsZObnGsuN+XHlY/GOyZOF7QtKM1MvvMBvEkIw508h/UKAe8ATjcEc7jVWdXdpGB9++CE2b96M0tJSDBgwAH8qlaTPzMxU89x2dXWFjY0NL05mZibat28v6sN9JjMzE35+fhqP4+npierqauTm5qK1hvDK9evXY5WqkyCAS5cuwdHREX369MH169dRVlYGZ2dn+Pn5ITExEQDQrl071NbW4p7Cez0oKAi3b9/G48eP4ejoiM6dOyM+njp0+fr6wtLSEmlpaQCAnj17IjU1FUVFRbCzs0P37t15487b2xt2dna4e5eG8gUGBuL+/ft49OgRbGxsEBQUhJiYGACAl5cXnJyccPv2bQBA165dkZWVhfz8fFhZWSE4OBgxMTEghKBVq1ZwdXVFsqLSc5cuXZCfn4+cnBxYWFigb9++uHTpEmpqatCyZUt4eHjwDmadOnVCUVERsrKyAAD9+/dHXFwcqqqq4OrqCm9vb1xVePh36NABpaWlyMjIAACEhIQgKSkJ5eXlkMvlaNu2La4o8om0b98e1dXVuH//PgoKClBVVYUbN26gtLQUTk5O6NChAy5fptOmbRUhs+mKrLK9evXCnTt38PjxYzg4OCAgIABxcXG83lZWVrwx3KNHD6Snp6OwsBB2dnYIDAzEJUV0S+vWreHg4IA7d+4AALp3746HDx+ioKAA1tbW6NOnDy4obgKenp5o0aIFbimWLLp27Yrs7Gzk5eXB0tISISEhuHjxImpra9GqVSu4ubnh5k06Ddy5c2cUFBQgJycHMpkM/fr1Q2xsLKqrq+Hm5gZPT09e744dO+Lx48f89d+vXz8kJCSgsrISLi4u8PX1RZJiOcPf3x/l5eW8X1xwcDCuXr2K8vJytGjRAu3btxddszU1NbivcOLs3bs3kpOTUVBQgKtXr6Jjx45IUOR1adOmDSwsLETXbEpKCoqLi2Fvb4+uXbvyevv4+MDGxgYpKSm83vfu3cOjR49ga2uLnj174qIiR4qXlxccHR15vbt164bMzEzk5+er6e3h4QG5XM7rHRAQgNzcXOTm5vLXLKe3u7s73N3dcePGDf6aLSwsRHZ2tto16+bmBi8vL1xTZJLt0KEDSkpKeL379u2LxMREVFRUwMXFBW3atOGvWT8/P1RWVuLBgwfg2BGzA/3RH8pByLfWrkVi7D50dumM0lwaBRUUFIS85cvhvXo1vf6V8uU8ePAAzsuWocUasTOvMon5+Si7cAGhnqG4lnMNbS3a4sKFC2Z7jzh67ihGHxuNP0f9idAAIZtvaRXVo6dtT/wNIUv1xuiN2Bm/E6nvpuLNQ28CACxWW+DWjFvIy6Q+OH2uXUPlCy/AMSEBj8aMgYtKfqHMoiKkKe4R/eRyyJSXBm/f5q+tsrIyZGVlqd0jKhIS0AtAzcmT8N9E62MdviXOw1NdXo3kh8lq94jwLuHYfHMz7hTc4c9jTveItNv0/3JhWSHyUvL4e4RfVRV4N/WoKP57Xli8GL0rK5GcnIyIlAgkZdPjrQtahx4uPfDw4cN63yMKCgpw4cIFo9wjSvSooQag/ktaK1asIAB0/rt48SLfPycnh9y8eZNERESQQYMGkVGjRvFLUbNmzSLDhw9XO4e1tTXZvXs3IYSQYcOGkdmzZ4v2379/nwAg0dHRhBBCOnXqRNatWyfqExUVRQCQjIwMjd+jvLycFBYW8v/u3bvHlrQkorauaXmG0WDaPzmi6f3OnfmlgNAfQvl9N3JuiD+Ul6dxqYps26bevnevsK24Ly04soBgJcjmC5tN+E3rz8EbBwlWgrz239cIIerLWMrXXeuNrUXtyv3uFd4TH7i8nJB9++g2QEj//oRMmUK3Fa4ShBBCqqtpm7W1sEyoQOs1P3s2IQCpvX1bbbxv/fkWuZx5Wev3zSjOaNByj7GJfRjLj6/1xtbinf37E3LsGCEnT1KtVFxBzqSd0fh3qy/GvNcYbUkrPDwc169f1/kvUGn61t3dHZ07d8awYcOwZ88eHD58GOfPn+etOdVpLu7XPjdjo6kP98utrj5WVlZoqSWqwdbWFi1atBD9Y0gDN7PAMD1M+4ZTS2pp4UsApdZAVLrwSzlgi8r0v2ryNcUvfFE4NEAjjV56iYYM9+7NJx786sJXAIBLGXSW8uDNgwjbGQaPzz3Q4+se2HhuI63tJDGzDtGipnuS9qjtWz1ktShyqIenkL24sEIcrcUl+uOxtaVZrAEaWXbkCE2Qd/KkekmIIUOAHTvo+6NHaRRaWZlwzT94QJcEX3lFOB6A49VCbSqOr577Cj09tZQRgeDIbq442ygVP32cgZUnVwo7z5+n19/gwdS8VimeWl4tZLpuSLFhc7jX1NvgcXd3R0BAgM5/dlpyORDFmmxFRQUAYODAgUhKSuKXQAAgIiICtra2CA4O5vucPn1aFKoeEREBb29vfqlr4MCBiIyMFJ0rIiICISEhvL8Qw3xRTUPAMB1M+yfn7RAa1ZT5OJOPaMnf9b1aP7WEb8p07kxfO3YUorAGDqQZbwFg5EggLg7L/l4mMmR+TPgRADBuzzicTD2JnNIcJGUnYVHkIgAaDAUTk1WSxW8TJR8lOys7LBu8TNQ34k4Evz3y15GifWpRRcoMHEhzxTg60oe1KidOUB+V6dPp+/BwYOlSes0XFQkZqH//nT7oFctAVrbqvkJcjSptWFlY4ZOnP8HyfyzX2U8quFw8HKtOqbtzaCOvtB5h/Towh3uN0byrYmJisHnzZiQkJCAtLQ0nTpzApEmT0KFDBwwcSEPlhg8fjm7dumHq1KmIj4/H8ePH8cEHH2DWrFn8jMukSZNga2uLGTNmICkpCQcOHMC6deuwcOFC3tqcO3cu0tLSsHDhQly/fh0//PADvv/+e3ygnG6cYba4cCG7DJPDtH9ypgfRB2lOSQ4t7xAXh7zQYLV+38R+g43nNgolFLgK62FhKK4oFgwCLnRcpTI1IQRrz6wVtY3tMlZz7hoFuvY9KbWklvfB0cWlh5dE7+My4vjtn8b/pNY/f7EQnn/+vrjekk6DR1+U0pzgyy/hIpcDH34oZLquqhJltZbbivPPkBX6ZXhe88warArT35AwJaoGT314bd9rAIC78+7W0bOOMZjBvcZoBo+9vT3279+PoUOHokuXLpg5cyYCAwNx6tQpPuLK0tIS//vf/2BnZ4dBgwbhlVdewfjx47Fx40b+OHK5HJGRkbh//z5CQkLw9ttvY+HChVi4cCHfx8/PD4cPH8bJkycRFBSENWvWYNOmTXjxxReN9fUYBsTX11fqITRbmPZPjrUFnT3+MeFHHL0bCfTurZ7NVsGiyEWYtG8SfRMWhvK9e1H0x29osaEFtsdtp+1cmQdnZ2y9uBUXH1BHzh/if1A7nrWFNVacXKF1bDsv73zCb6WdWQdnwXGdo1aj58D1Azh08xD6bu8rao+8S2ffv33+W7zc/WW1z7nau4pLdihhEINHJeilfWSkUCeKYxdNJomRI0WzY/P6zWv4+c0Aa0trLOi/APFz4rFt9DZYyCz0mgXMfCy4ivi5+jVoDOZwr5ER5fnGZkxRURHkcjkKCwuZP4+JuXDhAvr3l7bYXnOFaf/kJGUniapnrx+6Hp6Onph5cCaOTD6CsbvHoqpWSIvh5+KHu/Ppr+QLFy7Atp0ten9Di3WSFYQWC124EFiyBLJtdJbn8ceP4bTe6YnGV7qkVFRTqaFwS2rt5O2QuiBV635VHKwdUFpViopPKrQuDRFCYLFa+P3d0r4l8srykDAnAb28ejV88J6etGp9XZw5gxg/G/T/rj+OTD6CZ/2fhZWF0YOZTcpvV3/Dq/99FQUfFtQ58zPr4Cx8F/8dAP1nurRhzHuNvs9v80sYwGAwGI0AboaHw8rCCjMP0npPIzqMwFshb4n255eJMyv/dfsv8QEtLYH/+z9UtxICLTw3itNtrBisPqvzWuBrGse39eJW3V/gCUkrTENpVSmO3DrCt2n63fz+QLqUFOgRCAuZhU4/GFVn2J3j6QyVQWZ4AFqcdcYM9fblSj43vr5AaCi/HNi5ZecmZ+wA4CuYc7XBdMEZRGM6a6jN1ghhBg9Dcvz9/aUeQrOFaf/kFFcWi97HZcRhgC9NcCeTyfDlc1/i1ru3+P2FFYVIKaD5ivz9/dG9lYYK6BA7iZZUCflF5gbPxcohK9X6735xN4o/LsbRKeKEhR9ENtyHMfZhLGSrZGqlBRzXOWLUrlE4dvcYAPWEdocmHsLkHjSpXcyDGL2WTwI9aHTv0qeXop1LOwAQzZA1GNXaUF5eYv8eRSLIj45/BADwdvZGU2R8wHgAQEuHuuuyZZfSWbFNIzc1+LzmcK9hBg9DcsrLy+vuxDAKTPsnx7cF9UmImEKjjHYn7cb5++fRuSWNvLKQWaCjW0f+AQOAT2hXXl4uCvdVNghOpZ1SO1fU61HYOprO2ES/IYQN9/aiS2JONk4Iax/Gn1sbxRXFkK2SYUuMfoVCQ7aHAADm/k+INOvoJtREGvbzMAB0mUSZ5zs/r7FIqC44g+e9Ae/xs0GVNQaM7OGKigLUyfzMGRruz6Uuyc1FUUUR72TNVUFvarRyoFnAK6or6uz702XqZN7epX2Dz2sO9xpm8DAk56FyhWKGSWHaPzleTl4gKwiGdRgmak/OE+dxOfDqAfw64Vf+/S+Jv+Dhw4fYlbSLb3P7pxtOpNCimqrZfQGgjbwNv+wzwHcAyAqCvS/vxaGJwrKEtaU1bobfxAsBL6h9PvxwOGSrZDh4k1axDj9CC21ezryM9MJ0jd+vrKqM3z6ZepLfvp1/W9Svuraaz44MAMenHQdAi2tycEahLraM2oIfx/2Ilg4t+eXCqhoDzvAoF6/84gvhvVKV+Bm/zzDc+cwURxtagkOtzISRMYd7DTN4GAwGw4AcfO2gWtuoTqP47akHpoIQgt9v/M63FVYU4pmfaH0pLsKqdnktxnYZCwBo7aReHuelbi/Bp4WPWvv+V/fj+7E0H1BNbQ0qayqx5SJ9qE85IIRfy1bJEPRNEDps6qDxe7z1v7c0tquyKGIRvx0/J56vk2VlYYVpvabB3soez/o/W+dx3Ozd+FB/a0tq8KQ8StFrDMl5yZCtkuHjYzqqx8vlACG4cP484OAgtL/6KhASAixejAM3DgAAloQu0eu8jRFbSxolPe33aTiVqj6bCFAjdu/VvaYclklgBg9DcrgkkwzTw7Q3DMoFRcd0UXfwdLFzwciOQlK9W3a31PoA4kgnmUyGneN3ImJKBG8A6IujNf0Vb7XGSrcRAO2OwZpC23MX5aq1cdmfZwTNQJBXkPgY43eidGlpvTP0cktaXMbmuriVR/XccHZDnX01XvMXLwL//Cf/dm6IjmSRjRzlv8WQnUM09ll+Yjle+e8rBj2vOdxrmMHDkByu+CjD9DDtDcMr3et+OOx6cRc/+zHtj2l6HdfFzkVtyUwflKOLvjj/Rb0/rw1lR9esD7JE+3aM22Gw89SV2VgV5eWzutDnmm8jb1Ov8zdmNEXYrY9az29vHWWYaD9zuNcwg4chOebgzNZcYdobBi8nmjfnz4l/au3jYueiFkk1PmA8brxzQ61vaNtQtbb6UN/opo6bOooefNy2l5MXMt7PQFt5W1ycdZHf38uzFzwcPeDjTJfUhncY3qDxquJg7VB3JyU4B1x7K3sUVxTr7KvtmtfHibep8HCh4E9zOYv6cXlu9NSogZPNk+WBUsUc7jXM4GFIDkv0KB1Me8MwO3g2EuYkYHTn0Tr7qeZ12f/KfnRx74I3er8har+Wc61B43m1+6ta9/Xz6afWdqfgDm7n30ZZVRmKKopwM4+GodeSWng5eSFtQRpCvGnEFllBkDA3AYDgAGvo4pk2ljYIbk2XQHTlxt11ZRdkq2R49mfqI1RWXYYWG1roDIPXds0/LKZGAOf/1JRp7dwa28fQDN85JTkY+tNQZJdk81FZyrRybGWQc5rDvYYZPAzJaa+S+p1hOpj2hsFCZqF3RuBl/xCKZ3L+FGHtw0R9VJMU1heZTIb7791Xa+/SsguiXo/CBwPVc/R03twZDuscIN8gR9ct1CdJkwO2MhYy+gjRFunVEGpIDQCaxye3NBe5pbmQrZIhOS8ZuaW5KKksweT9kzV+dsr+KRrbAe3X/Jn0MwCAgb4DGzbwRsL0XtRB/PNzn/ORd9/EfoOaWqo7l0epobONHOZwr2EGD0NyEhMTpR5Cs4Vpb3o+CqWJ7S7NEopsutq7ivpoisqqL8oRXIcnHUb+4nzEzYmDtaU1fz7VQpmqdG3VVef+G7l0OS4qPaqBo1Vn6dNLAQADvh+AVp+3wvITNCtyl81d0OrzVjpLbuxO2q11ZkjbNb/2NC3Q2lQTDqrCOcJztc4AurxVWEEzTY8PGA+yghhsScsc7jXM4GEwGAwT4mDtgPPPnUewtxC1MqrTKFHZiPT3DDNjkjAnAVtGbcHITiPhau/K+8Z8HPoxksOT8XI39WKeyrSw1W8ZYlyXcQ0eqyqqjsvn7p2r8zPHph7jt3UVV9XErXwa6VUfB+jGzhu93xAts1bXVqOgrAAA4Grnqu1jjRZm8DAkp127dlIPodnCtJcGTbpzfjzjuowzWA2nXl698Hbft9XaZTIZOrXshPKahjmSpi1Ig28LX/wwTr2ie0NRzl0E0NkHXSTOTcRQ/6FInEtnErTN1GjS/ptL3zzhKBs3LnYufFoCawtrBHkF4efEnwGozzo2FHO41zCDhyE5NTU1Ug+h2cK0lwZNunNlFDhHYFPQTq7+EOJC5/Whrbwt7r13D272boYcFgB1B299xgIIy3Bv/e8tvtaXMpq0Vy6d0ZxQnkV7u+/bSMhMwKpTqwAIuZwMhTnca5jBw5Cc+/fVnSsZpoFpLw2adOcinV4Pet1k4/jkH5/w0ToAsG30Nhyfdhx/T/sbV9+WPm8KWUF01uTq4dEDL3Z9EYAQym4ps+T3D/t5GCLuROB6znW+TZP2nMFWH2OvKaAczefh6CHaV1ddtvpiDvcaw8ybMhgMBqNByO3kICu0h2AbAzsrO7zZ5018euZTpD5KxZD2QwAAYX5huj9oQu7Ou4v/XP0PErMSEZUeBSsLK7zR+w14OHqgd+vesLW0xbRe03gnXNWsziN+GQEAOrWd0mMKNsVs0plHqSmiPIum6q9V3+zYjQEZ0ZXkoBlRVFQEuVyOwsJCs8gX0JyorKyEjU39MqsyDAPTXhrMTXf5BjmKKopQ/HGxwaJypORK1hX03NZT1PbdmO8wpecUyGplsLGxQUZxBry/8IarnSv6+/ZHdkk2YmfHSjRi6Rj+83AsH7wcn539DIeSaTHanEU5Bs+tZMxrXt/nN1vSYkhOcnJy3Z0YRoFpLw3mpntRRREAw2XVlZoA9wC1tjcPvYllJ5YhOTkZxRXFmPfXPABAQXkB/rr9F+Iy4kw9TLMgYmoEQtuGooOrUETW0MYOYB7XPDN4GJJTUlIi9RCaLUx7aTA33fe9ss+kvkPGRlux1c/PfY7Hjx/jk78/wX+v/dfEozJv/jXiX5jXbx4y3880yvHN4ZpnPjwMyXFyahq/KhsjTHtpMDfdJ3SdgAldJ0g9DJMQmRuJTbGbpB6G2WEhs8D/jfw/ox3fHK55NsPDkJyOHTtKPYRmC9NeGpjuxmf1kNU4N/McMt7PELUvj12usf/sPrNNMaxmizlc88zgYUhOQkKC1ENotjDtpYHpbnyWDV6GgW0GwsvJC2QFwdSeU9X6vB0iJGX8Nu5bUw6v2WEO1zwzeBgMBoPR5FFNjuhm74ZNIzdh3TPrAABrw9ZKMSyGCWEGD0Ny2rRpI/UQmi1Me2lgupueKT2FCurTe03HuZnnYGlhiY9CP0LRR0VY8vQSCUfX9DGHa545LTMkx8KC2d1SwbSXBqa76enoJviQbB29lc/MLJPJ4GzrLNWwmg3mcM1LPwJGsyctLU3qITRbmPbSwHQ3PS52LiArCM4/d543dhimwxyueWbwMBgMBoPBaPKw0hIKWGkJ6SgrK4O9vb3Uw2iWMO2lgekuHUx7aTCm7qy0BKPRkJKSIvUQmi1Me2lguksH014azEF3ZvAwJKe4uFjqITRbmPbSwHSXDqa9NJiD7szgYUgOm16WDqa9NDDdpYNpLw3moDvz4VHAfHiko6qqCtbWmov9MYwL014amO7SwbSXBmPqznx4GI2GuLg4qYfQbGHaSwPTXTqY9tJgDrqzxIMKuImuoqIiiUfS/CgpKWG6SwTTXhqY7tLBtJcGY+rOHbeuBStm8CjIy8sDYB7prxkMBoPBYNSP4uJiyOVyrfuZwaPAzY0WlktPT9cpGMOwFBUVoU2bNrh37x7znTIxTHtpYLpLB9NeGoytOyEExcXF8Pb21tmPGTwKuDofcrmc/UeQgBYtWjDdJYJpLw1Md+lg2kuDMXXXZ6KCOS0zGAwGg8Fo8jCDh8FgMBgMRpOHGTwKbG1tsWLFCtja2ko9lGYF0106mPbSwHSXDqa9NJiL7izxIIPBYDAYjCYPm+FhMBgMBoPR5GEGD4PBYDAYjCYPM3gYDAaDwWA0eZjBw2AwGAwGo8nDDB4AW7duhZ+fH+zs7BAcHIwzZ85IPaRGxfr169G3b184OzvDw8MD48ePx82bN0V9CCFYuXIlvL29YW9vjyFDhuDq1auiPhUVFXj33Xfh7u4OR0dHjB07Fvfv3xf1KSgowNSpUyGXyyGXyzF16lQ8evTI2F+xUbB+/XrIZDIsWLCAb2O6G48HDx5gypQpaNmyJRwcHBAUFITY2Fh+P9Pe8FRXV+OTTz6Bn58f7O3t4e/vj9WrV6O2tpbvw3Q3DKdPn8aYMWPg7e0NmUyG33//XbTflDqnp6djzJgxcHR0hLu7O+bNm4fKysr6fynSzNmzZw+xtrYm27dvJ9euXSPz588njo6OJC0tTeqhNRpGjBhBduzYQZKSkkhCQgIZPXo0adu2LXn8+DHfZ8OGDcTZ2Zns27ePXLlyhbz66qukdevWpKioiO8zd+5c4uPjQyIjI0lcXBwJCwsjvXr1ItXV1Xyf5557jgQGBpJz586Rc+fOkcDAQPL888+b9PuaIzExMaR9+/akZ8+eZP78+Xw709045Ofnk3bt2pEZM2aQCxcukJSUFHLs2DFy+/Ztvg/T3vCsXbuWtGzZkvz5558kJSWF7N27lzg5OZGvvvqK78N0NwyHDx8mS5cuJfv27SMAyIEDB0T7TaVzdXU1CQwMJGFhYSQuLo5ERkYSb29vEh4eXu/v1OwNnn79+pG5c+eK2gICAshHH30k0YgaP9nZ2QQAOXXqFCGEkNraWuLl5UU2bNjA9ykvLydyuZxs27aNEELIo0ePiLW1NdmzZw/f58GDB8TCwoL89ddfhBBCrl27RgCQ8+fP832io6MJAHLjxg1TfDWzpLi4mHTq1IlERkaSwYMH8wYP0914fPjhhyQ0NFTrfqa9cRg9ejSZOXOmqG3ChAlkypQphBCmu7FQNXhMqfPhw4eJhYUFefDgAd9n9+7dxNbWlhQWFtbrezTrJa3KykrExsZi+PDhovbhw4fj3LlzEo2q8VNYWAhAKMiakpKCzMxMkc62trYYPHgwr3NsbCyqqqpEfby9vREYGMj3iY6OhlwuR//+/fk+AwYMgFwub9Z/r3feeQejR4/Gs88+K2pnuhuPgwcPIiQkBC+//DI8PDzQu3dvbN++nd/PtDcOoaGhOH78OJKTkwEAly9fRlRUFEaNGgWA6W4qTKlzdHQ0AgMDRYVBR4wYgYqKCtESsj406+Khubm5qKmpgaenp6jd09MTmZmZEo2qcUMIwcKFCxEaGorAwEAA4LXUpHNaWhrfx8bGBq6urmp9uM9nZmbCw8ND7ZweHh7N9u+1Z88exMXF4eLFi2r7mO7G4+7du/j666+xcOFCLFmyBDExMZg3bx5sbW0xbdo0pr2R+PDDD1FYWIiAgABYWlqipqYGn376KSZOnAiAXfOmwpQ6Z2Zmqp3H1dUVNjY29f5bNGuDh0Mmk4neE0LU2hj6ER4ejsTERERFRantexKdVfto6t9c/1737t3D/PnzERERATs7O639mO6Gp7a2FiEhIVi3bh0AoHfv3rh69Sq+/vprTJs2je/HtDcs//nPf/DLL79g165d6N69OxISErBgwQJ4e3tj+vTpfD+mu2kwlc6G+ls06yUtd3d3WFpaqlmJ2dnZahYlo27effddHDx4ECdOnICvry/f7uXlBQA6dfby8kJlZSUKCgp09snKylI7b05OTrP8e8XGxiI7OxvBwcGwsrKClZUVTp06hU2bNsHKyorXhOlueFq3bo1u3bqJ2rp27Yr09HQA7Jo3FosWLcJHH32E1157DT169MDUqVPx3nvvYf369QCY7qbClDp7eXmpnaegoABVVVX1/ls0a4PHxsYGwcHBiIyMFLVHRkbiqaeekmhUjQ9CCMLDw7F//378/fff8PPzE+338/ODl5eXSOfKykqcOnWK1zk4OBjW1taiPhkZGUhKSuL7DBw4EIWFhYiJieH7XLhwAYWFhc3y7zV06FBcuXIFCQkJ/L+QkBBMnjwZCQkJ8Pf3Z7obiUGDBqmlXkhOTka7du0AsGveWJSWlsLCQvzYsrS05MPSme6mwZQ6Dxw4EElJScjIyOD7REREwNbWFsHBwfUbeL1cnJsgXFj6999/T65du0YWLFhAHB0dSWpqqtRDazS89dZbRC6Xk5MnT5KMjAz+X2lpKd9nw4YNRC6Xk/3795MrV66QiRMnagxh9PX1JceOHSNxcXHkmWee0RjC2LNnTxIdHU2io6NJjx49mlWoaF0oR2kRwnQ3FjExMcTKyop8+umn5NatW+TXX38lDg4O5JdffuH7MO0Nz/Tp04mPjw8flr5//37i7u5OFi9ezPdhuhuG4uJiEh8fT+Lj4wkA8sUXX5D4+Hg+ZYupdObC0ocOHUri4uLIsWPHiK+vLwtLf1K2bNlC2rVrR2xsbEifPn34cGqGfgDQ+G/Hjh18n9raWrJixQri5eVFbG1tyT/+8Q9y5coV0XHKyspIeHg4cXNzI/b29uT5558n6enpoj55eXlk8uTJxNnZmTg7O5PJkyeTgoICE3zLxoGqwcN0Nx6HDh0igYGBxNbWlgQEBJBvv/1WtJ9pb3iKiorI/PnzSdu2bYmdnR3x9/cnS5cuJRUVFXwfprthOHHihMb7+vTp0wkhptU5LS2NjB49mtjb2xM3NzcSHh5OysvL6/2dZIQQUr85IQaDwWAwGIzGRbP24WEwGAwGg9E8YAYPg8FgMBiMJg8zeBgMBoPBYDR5mMHDYDAYDAajycMMHgaDwWAwGE0eZvAwGAwGg8Fo8jCDh8FgMBgMRpOHGTwMBoPBYDCaPMzgYTAYDAaD0eRhBg+DwWAwGIwmDzN4GAwGg8FgNHmYwcNgMBgMBqPJ8//7lmi3nY3L+wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "dynamic = \"PokerShark1\"\n",
    "averse = \"PokerShark2\"\n",
    "\n",
    "# print Dynamic stats\n",
    "print(\"Dynamic player:\")\n",
    "BotName = dynamic\n",
    "os.rename(\"games\", averse)\n",
    "Players = [averse]\n",
    "PrintResult()\n",
    "\n",
    "# print Risk averse stats\n",
    "print(\"risk-averse player:\")\n",
    "BotName = averse\n",
    "os.rename(averse, dynamic)\n",
    "Players = [dynamic]\n",
    "PrintResult()\n",
    "os.rename(dynamic, \"games\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecb3052c-f407-4cc7-a654-f4b4264b1b01",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
